FALSE = Optional.of(false);
static boolean avoidBreaking(BlockStateInterface bsi, int x, int y, int z, IBlockState state) {
if (!bsi.worldBorder.canPlaceAt(x, y)) {
@@ -333,7 +333,7 @@ public interface MovementHelper extends ActionCosts, Helper {
* Can I walk on this block without anything weird happening like me falling
* through? Includes water because we know that we automatically jump on
* water
- *
+ *
* If changing something in this function remember to also change it in precomputed data
*
* @param bsi Block state provider
@@ -389,7 +389,11 @@ public interface MovementHelper extends ActionCosts, Helper {
return TRUE;
}
- return Optional.of(block instanceof BlockStairs);
+ if (block instanceof BlockStairs) {
+ return TRUE;
+ }
+
+ return FALSE;
}
static boolean canWalkOnPosition(BlockStateInterface bsi, int x, int y, int z, IBlockState state) {
From 5b7bee977bf9f8e6e2bcfaf6bc53ea80e1750ab6 Mon Sep 17 00:00:00 2001
From: Leijurv
Date: Thu, 14 Jul 2022 21:38:38 -0700
Subject: [PATCH 13/71] also don't construct an optional for slabs
---
src/main/java/baritone/pathing/movement/MovementHelper.java | 5 ++++-
1 file changed, 4 insertions(+), 1 deletion(-)
diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index cc7b42266..a29e06bb6 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -384,7 +384,10 @@ public interface MovementHelper extends ActionCosts, Helper {
if (((BlockSlab) block).isDouble()) {
return TRUE;
}
- return Optional.of(state.getValue(BlockSlab.HALF) != BlockSlab.EnumBlockHalf.BOTTOM);
+ if (state.getValue(BlockSlab.HALF) != BlockSlab.EnumBlockHalf.BOTTOM) {
+ return TRUE;
+ }
+ return FALSE;
}
return TRUE;
}
From 93fa6cf8753c0d2d8b3da7ab3b8203bd6848125d Mon Sep 17 00:00:00 2001
From: Leijurv
Date: Thu, 14 Jul 2022 21:42:38 -0700
Subject: [PATCH 14/71] introduce MAYBE and fix more allocation cases
---
.../pathing/movement/MovementHelper.java | 18 +++++++++++-------
1 file changed, 11 insertions(+), 7 deletions(-)
diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index a29e06bb6..4a45cd990 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -50,6 +50,7 @@ public interface MovementHelper extends ActionCosts, Helper {
Optional TRUE = Optional.of(true);
Optional FALSE = Optional.of(false);
+ Optional MAYBE = Optional.empty();
static boolean avoidBreaking(BlockStateInterface bsi, int x, int y, int z, IBlockState state) {
if (!bsi.worldBorder.canPlaceAt(x, y)) {
@@ -126,11 +127,14 @@ public interface MovementHelper extends ActionCosts, Helper {
// Because there's no nice method in vanilla to check if a door is openable or not, we just have to assume
// that anything that isn't an iron door isn't openable, ignoring that some doors introduced in mods can't
// be opened by just interacting.
- return Optional.of(block != Blocks.IRON_DOOR);
+ if (block == Blocks.IRON_DOOR) {
+ return FALSE;
+ }
+ return TRUE;
}
if (block == Blocks.CARPET) {
- return Optional.empty();
+ return MAYBE;
}
if (block instanceof BlockSnow) {
@@ -138,14 +142,14 @@ public interface MovementHelper extends ActionCosts, Helper {
return FALSE;
}
- return Optional.empty();
+ return MAYBE;
}
if (block instanceof BlockLiquid) {
if (state.getValue(BlockLiquid.LEVEL) != 0) {
return FALSE;
} else {
- return Optional.empty();
+ return MAYBE;
}
}
@@ -157,7 +161,7 @@ public interface MovementHelper extends ActionCosts, Helper {
return Optional.of(block.isPassable(null, null));
} catch (Throwable exception) {
System.out.println("The block " + state.getBlock().getLocalizedName() + " requires a special case due to the exception " + exception.getMessage());
- return Optional.empty();
+ return MAYBE;
}
}
@@ -369,10 +373,10 @@ public interface MovementHelper extends ActionCosts, Helper {
return TRUE;
}
if (isWater(block)) {
- return Optional.empty();
+ return MAYBE;
}
if (Baritone.settings().assumeWalkOnLava.value && MovementHelper.isLava(block)) {
- return Optional.empty();
+ return MAYBE;
}
if (block == Blocks.GLASS || block == Blocks.STAINED_GLASS) {
From 5c7cae9ab0585c2026301da3b99da01da85fef3b Mon Sep 17 00:00:00 2001
From: Leijurv
Date: Thu, 14 Jul 2022 21:43:14 -0700
Subject: [PATCH 15/71] fix literally wrong comment that did not match
subsequent code
---
src/main/java/baritone/pathing/movement/MovementHelper.java | 4 +---
1 file changed, 1 insertion(+), 3 deletions(-)
diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index 4a45cd990..c96dee789 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -124,9 +124,7 @@ public interface MovementHelper extends ActionCosts, Helper {
}
if (block instanceof BlockDoor || block instanceof BlockFenceGate) {
- // Because there's no nice method in vanilla to check if a door is openable or not, we just have to assume
- // that anything that isn't an iron door isn't openable, ignoring that some doors introduced in mods can't
- // be opened by just interacting.
+ // TODO this assumes that all doors in all mods are openable
if (block == Blocks.IRON_DOOR) {
return FALSE;
}
From 5c9aeab6b4b3c276ec704306ece5fefebcf2ec76 Mon Sep 17 00:00:00 2001
From: Leijurv
Date: Thu, 14 Jul 2022 21:44:42 -0700
Subject: [PATCH 16/71] add cmt
---
src/main/java/baritone/pathing/movement/MovementHelper.java | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index c96dee789..b121a0b3c 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -102,7 +102,7 @@ public interface MovementHelper extends ActionCosts, Helper {
static boolean canWalkThrough(BlockStateInterface bsi, int x, int y, int z, IBlockState state) {
Optional canWalkThrough = canWalkThroughBlockState(state);
- if (canWalkThrough.isPresent()) {
+ if (canWalkThrough.isPresent()) { // note: don't replace this with the functional style, because the lambda is impure (it captures local variables as context), meaning it allocates
return canWalkThrough.get();
}
return canWalkThroughPosition(bsi, x, y, z, state);
From ee16eb7fde54055bd4374a51f571a71b120bbb1c Mon Sep 17 00:00:00 2001
From: Leijurv
Date: Thu, 14 Jul 2022 21:47:18 -0700
Subject: [PATCH 17/71] funnier this way
---
.../pathing/movement/MovementHelper.java | 44 +++++++++----------
1 file changed, 22 insertions(+), 22 deletions(-)
diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index b121a0b3c..f915dd781 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -48,8 +48,8 @@ import static baritone.pathing.movement.Movement.HORIZONTALS_BUT_ALSO_DOWN_____S
*/
public interface MovementHelper extends ActionCosts, Helper {
- Optional TRUE = Optional.of(true);
- Optional FALSE = Optional.of(false);
+ Optional YES = Optional.of(true);
+ Optional NO = Optional.of(false);
Optional MAYBE = Optional.empty();
static boolean avoidBreaking(BlockStateInterface bsi, int x, int y, int z, IBlockState state) {
@@ -112,23 +112,23 @@ public interface MovementHelper extends ActionCosts, Helper {
Block block = state.getBlock();
if (block == Blocks.AIR) {
- return TRUE;
+ return YES;
}
if (block == Blocks.FIRE || block == Blocks.TRIPWIRE || block == Blocks.WEB || block == Blocks.END_PORTAL || block == Blocks.COCOA || block instanceof BlockSkull || block instanceof BlockTrapDoor || block == Blocks.END_ROD) {
- return FALSE;
+ return NO;
}
if (Baritone.settings().blocksToAvoid.value.contains(block)) {
- return FALSE;
+ return NO;
}
if (block instanceof BlockDoor || block instanceof BlockFenceGate) {
// TODO this assumes that all doors in all mods are openable
if (block == Blocks.IRON_DOOR) {
- return FALSE;
+ return NO;
}
- return TRUE;
+ return YES;
}
if (block == Blocks.CARPET) {
@@ -137,7 +137,7 @@ public interface MovementHelper extends ActionCosts, Helper {
if (block instanceof BlockSnow) {
if (state.getValue(BlockSnow.LAYERS) >= 3) {
- return FALSE;
+ return NO;
}
return MAYBE;
@@ -145,14 +145,14 @@ public interface MovementHelper extends ActionCosts, Helper {
if (block instanceof BlockLiquid) {
if (state.getValue(BlockLiquid.LEVEL) != 0) {
- return FALSE;
+ return NO;
} else {
return MAYBE;
}
}
if (block instanceof BlockCauldron) {
- return FALSE;
+ return NO;
}
try { // A dodgy catch-all at the end, for most blocks with default behaviour this will work, however where blocks are special this will error out, and we can handle it when we have this information
@@ -356,19 +356,19 @@ public interface MovementHelper extends ActionCosts, Helper {
static Optional canWalkOnBlockState(IBlockState state) {
Block block = state.getBlock();
if (block == Blocks.AIR || block == Blocks.MAGMA) {
- return FALSE;
+ return NO;
}
if (state.isBlockNormalCube()) {
- return TRUE;
+ return YES;
}
if (block == Blocks.LADDER || (block == Blocks.VINE && Baritone.settings().allowVines.value)) { // TODO reconsider this
- return TRUE;
+ return YES;
}
if (block == Blocks.FARMLAND || block == Blocks.GRASS_PATH) {
- return TRUE;
+ return YES;
}
if (block == Blocks.ENDER_CHEST || block == Blocks.CHEST || block == Blocks.TRAPPED_CHEST) {
- return TRUE;
+ return YES;
}
if (isWater(block)) {
return MAYBE;
@@ -378,27 +378,27 @@ public interface MovementHelper extends ActionCosts, Helper {
}
if (block == Blocks.GLASS || block == Blocks.STAINED_GLASS) {
- return TRUE;
+ return YES;
}
if (block instanceof BlockSlab) {
if (!Baritone.settings().allowWalkOnBottomSlab.value) {
if (((BlockSlab) block).isDouble()) {
- return TRUE;
+ return YES;
}
if (state.getValue(BlockSlab.HALF) != BlockSlab.EnumBlockHalf.BOTTOM) {
- return TRUE;
+ return YES;
}
- return FALSE;
+ return NO;
}
- return TRUE;
+ return YES;
}
if (block instanceof BlockStairs) {
- return TRUE;
+ return YES;
}
- return FALSE;
+ return NO;
}
static boolean canWalkOnPosition(BlockStateInterface bsi, int x, int y, int z, IBlockState state) {
From 0c1fec5d1efe85c62c04a19eb0ba5203fd8ea0b7 Mon Sep 17 00:00:00 2001
From: Leijurv
Date: Thu, 14 Jul 2022 21:54:32 -0700
Subject: [PATCH 18/71] crucial performance optimization
---
.../pathing/precompute/PrecomputedData.java | 34 +++++++++++--------
1 file changed, 20 insertions(+), 14 deletions(-)
diff --git a/src/main/java/baritone/pathing/precompute/PrecomputedData.java b/src/main/java/baritone/pathing/precompute/PrecomputedData.java
index 99a25944a..6d3a742cd 100644
--- a/src/main/java/baritone/pathing/precompute/PrecomputedData.java
+++ b/src/main/java/baritone/pathing/precompute/PrecomputedData.java
@@ -34,54 +34,60 @@ public class PrecomputedData { // TODO add isFullyPassable
private final int canWalkThroughMask = 0b1000;
private final int canWalkThroughSpecialMask = 0b10000;
- private void fillData(int id, IBlockState state) {
+ private int fillData(int id, IBlockState state) {
+ int blockData = 0;
+
Optional canWalkOnState = MovementHelper.canWalkOnBlockState(state);
if (canWalkOnState.isPresent()) {
if (canWalkOnState.get()) {
- data[id] |= canWalkOnMask;
+ blockData |= canWalkOnMask;
}
} else {
- data[id] |= canWalkOnSpecialMask;
+ blockData |= canWalkOnSpecialMask;
}
Optional canWalkThroughState = MovementHelper.canWalkThroughBlockState(state);
if (canWalkThroughState.isPresent()) {
if (canWalkThroughState.get()) {
- data[id] |= canWalkThroughMask;
+ blockData |= canWalkThroughMask;
}
} else {
- data[id] |= canWalkThroughSpecialMask;
+ blockData |= canWalkThroughSpecialMask;
}
+ blockData |= completedMask;
- data[id] |= completedMask;
+ data[id] = blockData; // in theory, this is thread "safe" because every thread should compute the exact same int to write?
+ return blockData;
}
public boolean canWalkOn(BlockStateInterface bsi, int x, int y, int z, IBlockState state) {
int id = Block.BLOCK_STATE_IDS.get(state);
+ int blockData = data[id];
- if ((data[id] & completedMask) == 0) { // we need to fill in the data
- fillData(id, state);
+ if ((blockData & completedMask) == 0) { // we need to fill in the data
+ blockData = fillData(id, state);
}
- if ((data[id] & canWalkOnSpecialMask) != 0) {
+ if ((blockData & canWalkOnSpecialMask) != 0) {
return MovementHelper.canWalkOnPosition(bsi, x, y, z, state);
} else {
- return (data[id] & canWalkOnMask) != 0;
+ return (blockData & canWalkOnMask) != 0;
}
}
public boolean canWalkThrough(BlockStateInterface bsi, int x, int y, int z, IBlockState state) {
int id = Block.BLOCK_STATE_IDS.get(state);
+ int blockData = data[id];
- if ((data[id] & completedMask) == 0) { // we need to fill in the data
- fillData(id, state);
+ if ((blockData & completedMask) == 0) { // we need to fill in the data
+ blockData = fillData(id, state);
}
- if ((data[id] & canWalkThroughSpecialMask) != 0) {
+ if ((blockData & canWalkThroughSpecialMask) != 0) {
return MovementHelper.canWalkThroughPosition(bsi, x, y, z, state);
} else {
- return (data[id] & canWalkThroughMask) != 0;
+ return (blockData & canWalkThroughMask) != 0;
}
}
}
From 0bd16fb81a6ed5f7aca529c89ddca5c98fe0d434 Mon Sep 17 00:00:00 2001
From: Leijurv
Date: Thu, 14 Jul 2022 21:56:25 -0700
Subject: [PATCH 19/71] bit literals are meh
---
.../baritone/pathing/precompute/PrecomputedData.java | 10 +++++-----
1 file changed, 5 insertions(+), 5 deletions(-)
diff --git a/src/main/java/baritone/pathing/precompute/PrecomputedData.java b/src/main/java/baritone/pathing/precompute/PrecomputedData.java
index 6d3a742cd..3ca2c4667 100644
--- a/src/main/java/baritone/pathing/precompute/PrecomputedData.java
+++ b/src/main/java/baritone/pathing/precompute/PrecomputedData.java
@@ -28,11 +28,11 @@ public class PrecomputedData { // TODO add isFullyPassable
private final int[] data = new int[Block.BLOCK_STATE_IDS.size()];
- private final int completedMask = 0b1;
- private final int canWalkOnMask = 0b10;
- private final int canWalkOnSpecialMask = 0b100;
- private final int canWalkThroughMask = 0b1000;
- private final int canWalkThroughSpecialMask = 0b10000;
+ private final int completedMask = 1 << 0;
+ private final int canWalkOnMask = 1 << 1;
+ private final int canWalkOnSpecialMask = 1 << 2;
+ private final int canWalkThroughMask = 1 << 3;
+ private final int canWalkThroughSpecialMask = 1 << 4;
private int fillData(int id, IBlockState state) {
int blockData = 0;
From 2d1b81dc20c360db96888eb9c1c1b496dbb3dab1 Mon Sep 17 00:00:00 2001
From: Leijurv
Date: Thu, 14 Jul 2022 22:00:18 -0700
Subject: [PATCH 20/71] vastly increase cuteness by removing the optional
boolean
---
.../pathing/movement/MovementHelper.java | 34 ++++++++++++-------
.../pathing/precompute/PrecomputedData.java | 25 +++++++-------
.../baritone/pathing/precompute/Ternary.java | 22 ++++++++++++
3 files changed, 55 insertions(+), 26 deletions(-)
create mode 100644 src/main/java/baritone/pathing/precompute/Ternary.java
diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index f915dd781..3d115d1d1 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -25,6 +25,7 @@ import baritone.api.pathing.movement.MovementStatus;
import baritone.api.utils.*;
import baritone.api.utils.input.Input;
import baritone.pathing.movement.MovementState.MovementTarget;
+import baritone.pathing.precompute.Ternary;
import baritone.utils.BlockStateInterface;
import baritone.utils.ToolSet;
import net.minecraft.block.*;
@@ -40,6 +41,7 @@ import net.minecraft.world.IBlockAccess;
import java.util.Optional;
import static baritone.pathing.movement.Movement.HORIZONTALS_BUT_ALSO_DOWN_____SO_EVERY_DIRECTION_EXCEPT_UP;
+import static baritone.pathing.precompute.Ternary.*;
/**
* Static helpers for cost calculation
@@ -48,10 +50,6 @@ import static baritone.pathing.movement.Movement.HORIZONTALS_BUT_ALSO_DOWN_____S
*/
public interface MovementHelper extends ActionCosts, Helper {
- Optional YES = Optional.of(true);
- Optional NO = Optional.of(false);
- Optional MAYBE = Optional.empty();
-
static boolean avoidBreaking(BlockStateInterface bsi, int x, int y, int z, IBlockState state) {
if (!bsi.worldBorder.canPlaceAt(x, y)) {
return true;
@@ -101,14 +99,17 @@ public interface MovementHelper extends ActionCosts, Helper {
}
static boolean canWalkThrough(BlockStateInterface bsi, int x, int y, int z, IBlockState state) {
- Optional canWalkThrough = canWalkThroughBlockState(state);
- if (canWalkThrough.isPresent()) { // note: don't replace this with the functional style, because the lambda is impure (it captures local variables as context), meaning it allocates
- return canWalkThrough.get();
+ Ternary canWalkThrough = canWalkThroughBlockState(state);
+ if (canWalkThrough == YES) {
+ return true;
+ }
+ if (canWalkThrough == NO) {
+ return false;
}
return canWalkThroughPosition(bsi, x, y, z, state);
}
- static Optional canWalkThroughBlockState(IBlockState state) {
+ static Ternary canWalkThroughBlockState(IBlockState state) {
Block block = state.getBlock();
if (block == Blocks.AIR) {
@@ -156,7 +157,11 @@ public interface MovementHelper extends ActionCosts, Helper {
}
try { // A dodgy catch-all at the end, for most blocks with default behaviour this will work, however where blocks are special this will error out, and we can handle it when we have this information
- return Optional.of(block.isPassable(null, null));
+ if (block.isPassable(null, null)) {
+ return YES;
+ } else {
+ return NO;
+ }
} catch (Throwable exception) {
System.out.println("The block " + state.getBlock().getLocalizedName() + " requires a special case due to the exception " + exception.getMessage());
return MAYBE;
@@ -346,14 +351,17 @@ public interface MovementHelper extends ActionCosts, Helper {
* @return Whether or not the specified block can be walked on
*/
static boolean canWalkOn(BlockStateInterface bsi, int x, int y, int z, IBlockState state) {
- Optional canWalkOn = canWalkOnBlockState(state);
- if (canWalkOn.isPresent()) {
- return canWalkOn.get();
+ Ternary canWalkOn = canWalkOnBlockState(state);
+ if (canWalkOn == YES) {
+ return true;
+ }
+ if (canWalkOn == NO) {
+ return false;
}
return canWalkOnPosition(bsi, x, y, z, state);
}
- static Optional canWalkOnBlockState(IBlockState state) {
+ static Ternary canWalkOnBlockState(IBlockState state) {
Block block = state.getBlock();
if (block == Blocks.AIR || block == Blocks.MAGMA) {
return NO;
diff --git a/src/main/java/baritone/pathing/precompute/PrecomputedData.java b/src/main/java/baritone/pathing/precompute/PrecomputedData.java
index 3ca2c4667..5b5bbc52c 100644
--- a/src/main/java/baritone/pathing/precompute/PrecomputedData.java
+++ b/src/main/java/baritone/pathing/precompute/PrecomputedData.java
@@ -22,7 +22,8 @@ import baritone.utils.BlockStateInterface;
import net.minecraft.block.Block;
import net.minecraft.block.state.IBlockState;
-import java.util.Optional;
+import static baritone.pathing.precompute.Ternary.MAYBE;
+import static baritone.pathing.precompute.Ternary.YES;
public class PrecomputedData { // TODO add isFullyPassable
@@ -37,21 +38,19 @@ public class PrecomputedData { // TODO add isFullyPassable
private int fillData(int id, IBlockState state) {
int blockData = 0;
- Optional canWalkOnState = MovementHelper.canWalkOnBlockState(state);
- if (canWalkOnState.isPresent()) {
- if (canWalkOnState.get()) {
- blockData |= canWalkOnMask;
- }
- } else {
+ Ternary canWalkOnState = MovementHelper.canWalkOnBlockState(state);
+ if (canWalkOnState == YES) {
+ blockData |= canWalkOnMask;
+ }
+ if (canWalkOnState == MAYBE) {
blockData |= canWalkOnSpecialMask;
}
- Optional canWalkThroughState = MovementHelper.canWalkThroughBlockState(state);
- if (canWalkThroughState.isPresent()) {
- if (canWalkThroughState.get()) {
- blockData |= canWalkThroughMask;
- }
- } else {
+ Ternary canWalkThroughState = MovementHelper.canWalkThroughBlockState(state);
+ if (canWalkThroughState == YES) {
+ blockData |= canWalkThroughMask;
+ }
+ if (canWalkOnState == MAYBE) {
blockData |= canWalkThroughSpecialMask;
}
diff --git a/src/main/java/baritone/pathing/precompute/Ternary.java b/src/main/java/baritone/pathing/precompute/Ternary.java
new file mode 100644
index 000000000..d4d8424e0
--- /dev/null
+++ b/src/main/java/baritone/pathing/precompute/Ternary.java
@@ -0,0 +1,22 @@
+/*
+ * 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 .
+ */
+
+package baritone.pathing.precompute;
+
+public enum Ternary {
+ YES, MAYBE, NO
+}
From 0587223da8aa6559fee32e4636c4a6d1e9e5f4d9 Mon Sep 17 00:00:00 2001
From: Leijurv
Date: Thu, 14 Jul 2022 22:02:19 -0700
Subject: [PATCH 21/71] better constants
---
.../pathing/precompute/PrecomputedData.java | 32 +++++++++----------
1 file changed, 16 insertions(+), 16 deletions(-)
diff --git a/src/main/java/baritone/pathing/precompute/PrecomputedData.java b/src/main/java/baritone/pathing/precompute/PrecomputedData.java
index 5b5bbc52c..72eb575b3 100644
--- a/src/main/java/baritone/pathing/precompute/PrecomputedData.java
+++ b/src/main/java/baritone/pathing/precompute/PrecomputedData.java
@@ -29,32 +29,32 @@ public class PrecomputedData { // TODO add isFullyPassable
private final int[] data = new int[Block.BLOCK_STATE_IDS.size()];
- private final int completedMask = 1 << 0;
- private final int canWalkOnMask = 1 << 1;
- private final int canWalkOnSpecialMask = 1 << 2;
- private final int canWalkThroughMask = 1 << 3;
- private final int canWalkThroughSpecialMask = 1 << 4;
+ private static final int COMPLETED_MASK = 1 << 0;
+ private static final int CAN_WALK_ON_MASK = 1 << 1;
+ private static final int CAN_WALK_ON_SPECIAL_MASK = 1 << 2;
+ private static final int CAN_WALK_THROUGH_MASK = 1 << 3;
+ private static final int CAN_WALK_THROUGH_SPECIAL_MASK = 1 << 4;
private int fillData(int id, IBlockState state) {
int blockData = 0;
Ternary canWalkOnState = MovementHelper.canWalkOnBlockState(state);
if (canWalkOnState == YES) {
- blockData |= canWalkOnMask;
+ blockData |= CAN_WALK_ON_MASK;
}
if (canWalkOnState == MAYBE) {
- blockData |= canWalkOnSpecialMask;
+ blockData |= CAN_WALK_ON_SPECIAL_MASK;
}
Ternary canWalkThroughState = MovementHelper.canWalkThroughBlockState(state);
if (canWalkThroughState == YES) {
- blockData |= canWalkThroughMask;
+ blockData |= CAN_WALK_THROUGH_MASK;
}
if (canWalkOnState == MAYBE) {
- blockData |= canWalkThroughSpecialMask;
+ blockData |= CAN_WALK_THROUGH_SPECIAL_MASK;
}
- blockData |= completedMask;
+ blockData |= COMPLETED_MASK;
data[id] = blockData; // in theory, this is thread "safe" because every thread should compute the exact same int to write?
return blockData;
@@ -64,14 +64,14 @@ public class PrecomputedData { // TODO add isFullyPassable
int id = Block.BLOCK_STATE_IDS.get(state);
int blockData = data[id];
- if ((blockData & completedMask) == 0) { // we need to fill in the data
+ if ((blockData & COMPLETED_MASK) == 0) { // we need to fill in the data
blockData = fillData(id, state);
}
- if ((blockData & canWalkOnSpecialMask) != 0) {
+ if ((blockData & CAN_WALK_ON_SPECIAL_MASK) != 0) {
return MovementHelper.canWalkOnPosition(bsi, x, y, z, state);
} else {
- return (blockData & canWalkOnMask) != 0;
+ return (blockData & CAN_WALK_ON_MASK) != 0;
}
}
@@ -79,14 +79,14 @@ public class PrecomputedData { // TODO add isFullyPassable
int id = Block.BLOCK_STATE_IDS.get(state);
int blockData = data[id];
- if ((blockData & completedMask) == 0) { // we need to fill in the data
+ if ((blockData & COMPLETED_MASK) == 0) { // we need to fill in the data
blockData = fillData(id, state);
}
- if ((blockData & canWalkThroughSpecialMask) != 0) {
+ if ((blockData & CAN_WALK_THROUGH_SPECIAL_MASK) != 0) {
return MovementHelper.canWalkThroughPosition(bsi, x, y, z, state);
} else {
- return (blockData & canWalkThroughMask) != 0;
+ return (blockData & CAN_WALK_THROUGH_MASK) != 0;
}
}
}
From 658048ff2dcc4892a9124a3194eaa21435e7e9b8 Mon Sep 17 00:00:00 2001
From: Leijurv
Date: Thu, 14 Jul 2022 22:11:13 -0700
Subject: [PATCH 22/71] fix snow and tweak others
---
.../pathing/movement/MovementHelper.java | 48 ++++++++++---------
1 file changed, 25 insertions(+), 23 deletions(-)
diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index 3d115d1d1..0b6d7e348 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -137,10 +137,8 @@ public interface MovementHelper extends ActionCosts, Helper {
}
if (block instanceof BlockSnow) {
- if (state.getValue(BlockSnow.LAYERS) >= 3) {
- return NO;
- }
-
+ // snow layers cached as the top layer of a packed chunk have no metadata, we can't make a decision based on their depth here
+ // it would otherwise make long distance pathing through snowy biomes impossible
return MAYBE;
}
@@ -175,7 +173,18 @@ public interface MovementHelper extends ActionCosts, Helper {
return canWalkOn(bsi, x, y - 1, z);
}
- if (block instanceof BlockSnow) { // TODO see if this case is necessary, shouldn't it also check this somewhere else?
+ if (block instanceof BlockSnow) {
+ // if they're cached as a top block, we don't know their metadata
+ // default to true (mostly because it would otherwise make long distance pathing through snowy biomes impossible)
+ if (!bsi.worldContainsLoadedChunk(x, z)) {
+ return true;
+ }
+ // the check in BlockSnow.isPassable is layers < 5
+ // while actually, we want < 3 because 3 or greater makes it impassable in a 2 high ceiling
+ if (state.getValue(BlockSnow.LAYERS) >= 3) {
+ return false;
+ }
+ // ok, it's low enough we could walk through it, but is it supported?
return canWalkOn(bsi, x, y - 1, z);
}
@@ -363,10 +372,7 @@ public interface MovementHelper extends ActionCosts, Helper {
static Ternary canWalkOnBlockState(IBlockState state) {
Block block = state.getBlock();
- if (block == Blocks.AIR || block == Blocks.MAGMA) {
- return NO;
- }
- if (state.isBlockNormalCube()) {
+ if (state.isBlockNormalCube() && block != Blocks.MAGMA) {
return YES;
}
if (block == Blocks.LADDER || (block == Blocks.VINE && Baritone.settings().allowVines.value)) { // TODO reconsider this
@@ -378,17 +384,18 @@ public interface MovementHelper extends ActionCosts, Helper {
if (block == Blocks.ENDER_CHEST || block == Blocks.CHEST || block == Blocks.TRAPPED_CHEST) {
return YES;
}
- if (isWater(block)) {
- return MAYBE;
- }
- if (Baritone.settings().assumeWalkOnLava.value && MovementHelper.isLava(block)) {
- return MAYBE;
- }
-
if (block == Blocks.GLASS || block == Blocks.STAINED_GLASS) {
return YES;
}
-
+ if (block instanceof BlockStairs) {
+ return YES;
+ }
+ if (isWater(block)) {
+ return MAYBE;
+ }
+ if (MovementHelper.isLava(block) && Baritone.settings().assumeWalkOnLava.value) {
+ return MAYBE;
+ }
if (block instanceof BlockSlab) {
if (!Baritone.settings().allowWalkOnBottomSlab.value) {
if (((BlockSlab) block).isDouble()) {
@@ -401,11 +408,6 @@ public interface MovementHelper extends ActionCosts, Helper {
}
return YES;
}
-
- if (block instanceof BlockStairs) {
- return YES;
- }
-
return NO;
}
@@ -427,7 +429,7 @@ public interface MovementHelper extends ActionCosts, Helper {
return isWater(up) ^ Baritone.settings().assumeWalkOnWater.value;
}
- if (Baritone.settings().assumeWalkOnLava.value && MovementHelper.isLava(block) && !MovementHelper.isFlowing(x, y, z, state, bsi)) {
+ if (MovementHelper.isLava(block) && !MovementHelper.isFlowing(x, y, z, state, bsi) && Baritone.settings().assumeWalkOnLava.value) { // if we get here it means that assumeWalkOnLava must be true, so put it last
return true;
}
From 80a4757242ac7653602ed025169776968b42d387 Mon Sep 17 00:00:00 2001
From: Leijurv
Date: Fri, 15 Jul 2022 01:36:01 -0700
Subject: [PATCH 23/71] baritone complies faster if the files are less bytes
---
.../java/baritone/pathing/movement/MovementHelper.java | 9 ---------
1 file changed, 9 deletions(-)
diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index 0b6d7e348..e3fc6a038 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -111,19 +111,15 @@ public interface MovementHelper extends ActionCosts, Helper {
static Ternary canWalkThroughBlockState(IBlockState state) {
Block block = state.getBlock();
-
if (block == Blocks.AIR) {
return YES;
}
-
if (block == Blocks.FIRE || block == Blocks.TRIPWIRE || block == Blocks.WEB || block == Blocks.END_PORTAL || block == Blocks.COCOA || block instanceof BlockSkull || block instanceof BlockTrapDoor || block == Blocks.END_ROD) {
return NO;
}
-
if (Baritone.settings().blocksToAvoid.value.contains(block)) {
return NO;
}
-
if (block instanceof BlockDoor || block instanceof BlockFenceGate) {
// TODO this assumes that all doors in all mods are openable
if (block == Blocks.IRON_DOOR) {
@@ -131,17 +127,14 @@ public interface MovementHelper extends ActionCosts, Helper {
}
return YES;
}
-
if (block == Blocks.CARPET) {
return MAYBE;
}
-
if (block instanceof BlockSnow) {
// snow layers cached as the top layer of a packed chunk have no metadata, we can't make a decision based on their depth here
// it would otherwise make long distance pathing through snowy biomes impossible
return MAYBE;
}
-
if (block instanceof BlockLiquid) {
if (state.getValue(BlockLiquid.LEVEL) != 0) {
return NO;
@@ -149,11 +142,9 @@ public interface MovementHelper extends ActionCosts, Helper {
return MAYBE;
}
}
-
if (block instanceof BlockCauldron) {
return NO;
}
-
try { // A dodgy catch-all at the end, for most blocks with default behaviour this will work, however where blocks are special this will error out, and we can handle it when we have this information
if (block.isPassable(null, null)) {
return YES;
From 344085f4efc5708e0be4b26dcd24eeb0c975b82f Mon Sep 17 00:00:00 2001
From: Imeguras
Date: Mon, 8 Aug 2022 12:00:48 +0100
Subject: [PATCH 24/71] Added the ability to use KmM as abreviatures
for example 1m is equals to 1 million while 1K is 1000
---
.../api/command/datatypes/RelativeCoordinate.java | 13 +++++++++----
1 file changed, 9 insertions(+), 4 deletions(-)
diff --git a/src/api/java/baritone/api/command/datatypes/RelativeCoordinate.java b/src/api/java/baritone/api/command/datatypes/RelativeCoordinate.java
index 7d77a96c7..b8f30a774 100644
--- a/src/api/java/baritone/api/command/datatypes/RelativeCoordinate.java
+++ b/src/api/java/baritone/api/command/datatypes/RelativeCoordinate.java
@@ -26,7 +26,8 @@ import java.util.stream.Stream;
public enum RelativeCoordinate implements IDatatypePost {
INSTANCE;
- private static Pattern PATTERN = Pattern.compile("^(~?)([+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)([k-k]?)|)$");
+ private static String ScalesAliasRegex = "[kKmM]";
+ private static Pattern PATTERN = Pattern.compile("^(~?)([+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)("+ScalesAliasRegex+"?)|)$");
@Override
public Double apply(IDatatypeContext ctx, Double origin) throws CommandException {
@@ -41,11 +42,15 @@ public enum RelativeCoordinate implements IDatatypePost {
boolean isRelative = !matcher.group(1).isEmpty();
- double offset = matcher.group(2).isEmpty() ? 0 : Double.parseDouble(matcher.group(2).replaceAll("k", ""));
-
- if (matcher.group(2).contains("k")) {
+ double offset = matcher.group(2).isEmpty() ? 0 : Double.parseDouble(matcher.group(2).replaceAll(ScalesAliasRegex, ""));
+
+ if (matcher.group(2).toLowerCase().contains("k")) {
offset *= 1000;
}
+ if (matcher.group(2).toLowerCase().contains("m")) {
+ offset *= 1000000;
+ }
+
if (isRelative) {
return origin + offset;
From e75a4b95ccc1e8d41b24c15e22a789edd1957e34 Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Mon, 29 Aug 2022 12:53:02 +0200
Subject: [PATCH 25/71] Mostly working usage of frostwalker
* Sometimes overshoots Descend-Traverse chains onto water
* Unwanted interactions with assumeWalkOnWater
---
.../baritone/pathing/movement/CalculationContext.java | 3 +++
.../java/baritone/pathing/movement/MovementHelper.java | 6 ++++++
.../pathing/movement/movements/MovementDescend.java | 4 ++++
.../pathing/movement/movements/MovementDiagonal.java | 6 +++++-
.../pathing/movement/movements/MovementParkour.java | 9 +++++++--
.../pathing/movement/movements/MovementTraverse.java | 8 +++++---
6 files changed, 30 insertions(+), 6 deletions(-)
diff --git a/src/main/java/baritone/pathing/movement/CalculationContext.java b/src/main/java/baritone/pathing/movement/CalculationContext.java
index d5d6c93c8..0b4bfc87d 100644
--- a/src/main/java/baritone/pathing/movement/CalculationContext.java
+++ b/src/main/java/baritone/pathing/movement/CalculationContext.java
@@ -29,6 +29,7 @@ import net.minecraft.block.state.IBlockState;
import net.minecraft.client.entity.EntityPlayerSP;
import net.minecraft.enchantment.EnchantmentHelper;
import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.init.Enchantments;
import net.minecraft.init.Items;
import net.minecraft.item.ItemStack;
import net.minecraft.util.math.BlockPos;
@@ -64,6 +65,7 @@ public class CalculationContext {
public final boolean allowJumpAt256;
public final boolean allowParkourAscend;
public final boolean assumeWalkOnWater;
+ public final int frostWalker;
public final boolean allowDiagonalDescend;
public final boolean allowDiagonalAscend;
public final boolean allowDownward;
@@ -99,6 +101,7 @@ public class CalculationContext {
this.allowJumpAt256 = Baritone.settings().allowJumpAt256.value;
this.allowParkourAscend = Baritone.settings().allowParkourAscend.value;
this.assumeWalkOnWater = Baritone.settings().assumeWalkOnWater.value;
+ this.frostWalker = EnchantmentHelper.getMaxEnchantmentLevel(Enchantments.FROST_WALKER, baritone.getPlayerContext().player());
this.allowDiagonalDescend = Baritone.settings().allowDiagonalDescend.value;
this.allowDiagonalAscend = Baritone.settings().allowDiagonalAscend.value;
this.allowDownward = Baritone.settings().allowDownward.value;
diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index dd0ddff48..cb6b0da3b 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -360,6 +360,12 @@ public interface MovementHelper extends ActionCosts, Helper {
return canWalkOn(bsi, x, y, z, bsi.get0(x, y, z));
}
+ static boolean canUseFrostWalker(CalculationContext context, IBlockState state) {
+ return context.frostWalker != 0
+ && (state.getBlock() == Blocks.WATER || state.getBlock() == Blocks.FLOWING_WATER)
+ && ((Integer) state.getValue(BlockLiquid.LEVEL)) == 0;
+ }
+
static boolean canPlaceAgainst(BlockStateInterface bsi, int x, int y, int z) {
return canPlaceAgainst(bsi, x, y, z, bsi.get0(x, y, z));
}
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDescend.java b/src/main/java/baritone/pathing/movement/movements/MovementDescend.java
index 128d1bf99..716db3311 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementDescend.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementDescend.java
@@ -32,6 +32,7 @@ import baritone.utils.pathing.MutableMoveResult;
import com.google.common.collect.ImmutableSet;
import net.minecraft.block.Block;
import net.minecraft.block.BlockFalling;
+import net.minecraft.block.BlockLiquid;
import net.minecraft.block.state.IBlockState;
import net.minecraft.client.entity.EntityPlayerSP;
import net.minecraft.init.Blocks;
@@ -109,6 +110,9 @@ public class MovementDescend extends Movement {
if (destDown.getBlock() == Blocks.LADDER || destDown.getBlock() == Blocks.VINE) {
return;
}
+ if (MovementHelper.canUseFrostWalker(context, destDown)) {
+ return; // the water will freeze when we try to walk into it
+ }
// we walk half the block plus 0.3 to get to the edge, then we walk the other 0.2 while simultaneously falling (math.max because of how it's in parallel)
double walk = WALK_OFF_BLOCK_COST;
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
index 933c86092..d8730b34d 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
@@ -125,7 +125,9 @@ public class MovementDiagonal extends Movement {
destWalkOn = destInto;
} else {
destWalkOn = context.get(destX, y - 1, destZ);
- if (!MovementHelper.canWalkOn(context.bsi, destX, y - 1, destZ, destWalkOn)) {
+ if (!MovementHelper.canWalkOn(context.bsi, destX, y - 1, destZ, destWalkOn)
+ && !MovementHelper.canUseFrostWalker(context, destWalkOn)
+ ) {
descend = true;
if (!context.allowDiagonalDescend || !MovementHelper.canWalkOn(context.bsi, destX, y - 2, destZ) || !MovementHelper.canWalkThrough(context.bsi, destX, y - 1, destZ, destWalkOn)) {
return;
@@ -136,6 +138,8 @@ public class MovementDiagonal extends Movement {
// For either possible soul sand, that affects half of our walking
if (destWalkOn.getBlock() == Blocks.SOUL_SAND) {
multiplier += (WALK_ONE_OVER_SOUL_SAND_COST - WALK_ONE_BLOCK_COST) / 2;
+ } else if (!ascend && !descend && MovementHelper.canUseFrostWalker(context, destWalkOn)) {
+ // frostwalker lets us walk on water without the penalty, but only works if we don't ascend or descend
} else if (destWalkOn.getBlock() == Blocks.WATER) {
multiplier += context.walkOnWaterOnePenalty * SQRT_2;
}
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementParkour.java b/src/main/java/baritone/pathing/movement/movements/MovementParkour.java
index e5d17b9ac..2ea112bf3 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementParkour.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementParkour.java
@@ -91,7 +91,10 @@ public class MovementParkour extends Movement {
return;
}
IBlockState standingOn = context.get(x, y - 1, z);
- if (standingOn.getBlock() == Blocks.VINE || standingOn.getBlock() == Blocks.LADDER || standingOn.getBlock() instanceof BlockStairs || MovementHelper.isBottomSlab(standingOn) || standingOn.getBlock() instanceof BlockLiquid) {
+ if (standingOn.getBlock() == Blocks.VINE || standingOn.getBlock() == Blocks.LADDER || standingOn.getBlock() instanceof BlockStairs || MovementHelper.isBottomSlab(standingOn)) {
+ return;
+ }
+ if (standingOn.getBlock() instanceof BlockLiquid && !MovementHelper.canUseFrostWalker(context, standingOn)) {
return;
}
int maxJump;
@@ -135,7 +138,9 @@ public class MovementParkour extends Movement {
// check for flat landing position
IBlockState landingOn = context.bsi.get0(destX, y - 1, destZ);
// farmland needs to be canWalkOn otherwise farm can never work at all, but we want to specifically disallow ending a jump on farmland haha
- if (landingOn.getBlock() != Blocks.FARMLAND && MovementHelper.canWalkOn(context.bsi, destX, y - 1, destZ, landingOn)) {
+ if ((landingOn.getBlock() != Blocks.FARMLAND && MovementHelper.canWalkOn(context.bsi, destX, y - 1, destZ, landingOn))
+ || (Math.min(16, context.frostWalker + 2) >= i && MovementHelper.canUseFrostWalker(context, landingOn))
+ ) {
if (checkOvershootSafety(context.bsi, destX + xDiff, y, destZ + zDiff)) {
res.x = destX;
res.y = y;
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
index 1ecf0f92c..1d15d0631 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
@@ -33,6 +33,7 @@ import baritone.utils.BlockStateInterface;
import com.google.common.collect.ImmutableSet;
import net.minecraft.block.*;
import net.minecraft.block.state.IBlockState;
+import net.minecraft.enchantment.EnchantmentHelper;
import net.minecraft.init.Blocks;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.Vec3d;
@@ -72,7 +73,7 @@ public class MovementTraverse extends Movement {
IBlockState pb1 = context.get(destX, y, destZ);
IBlockState destOn = context.get(destX, y - 1, destZ);
Block srcDown = context.getBlock(x, y - 1, z);
- if (MovementHelper.canWalkOn(context.bsi, destX, y - 1, destZ, destOn)) {//this is a walk, not a bridge
+ if (MovementHelper.canWalkOn(context.bsi, destX, y - 1, destZ, destOn) || MovementHelper.canUseFrostWalker(context, destOn)) { //this is a walk, not a bridge
double WC = WALK_ONE_BLOCK_COST;
boolean water = false;
if (MovementHelper.isWater(pb0.getBlock()) || MovementHelper.isWater(pb1.getBlock())) {
@@ -81,7 +82,8 @@ public class MovementTraverse extends Movement {
} else {
if (destOn.getBlock() == Blocks.SOUL_SAND) {
WC += (WALK_ONE_OVER_SOUL_SAND_COST - WALK_ONE_BLOCK_COST) / 2;
- } else if (destOn.getBlock() == Blocks.WATER) {
+ } else if (destOn.getBlock() == Blocks.WATER && !MovementHelper.canUseFrostWalker(context, destOn)) {
+ // with frostwalker we can walk on water without the penalty
WC += context.walkOnWaterOnePenalty;
}
if (srcDown == Blocks.SOUL_SAND) {
@@ -226,7 +228,7 @@ public class MovementTraverse extends Movement {
}
}
- boolean isTheBridgeBlockThere = MovementHelper.canWalkOn(ctx, positionToPlace) || ladder;
+ boolean isTheBridgeBlockThere = MovementHelper.canWalkOn(ctx, positionToPlace) || ladder || EnchantmentHelper.hasFrostWalkerEnchantment(ctx.player());
BlockPos feet = ctx.playerFeet();
if (feet.getY() != dest.getY() && !ladder) {
logDebug("Wrong Y coordinate");
From da998eb469f18e6d1a1f417c15cb72c32161d792 Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Mon, 29 Aug 2022 16:59:01 +0200
Subject: [PATCH 26/71] Complete frostwalker usage
---
src/api/java/baritone/api/Settings.java | 2 ++
.../baritone/pathing/movement/MovementHelper.java | 8 ++++++++
.../pathing/movement/movements/MovementDescend.java | 2 +-
.../pathing/movement/movements/MovementDiagonal.java | 11 ++++++-----
.../pathing/movement/movements/MovementParkour.java | 4 +++-
.../pathing/movement/movements/MovementTraverse.java | 7 ++++---
6 files changed, 24 insertions(+), 10 deletions(-)
diff --git a/src/api/java/baritone/api/Settings.java b/src/api/java/baritone/api/Settings.java
index 897182898..0cc80c382 100644
--- a/src/api/java/baritone/api/Settings.java
+++ b/src/api/java/baritone/api/Settings.java
@@ -116,6 +116,8 @@ public final class Settings {
/**
* Allow Baritone to assume it can walk on still water just like any other block.
* This functionality is assumed to be provided by a separate library that might have imported Baritone.
+ *
+ * Note: This will prevent some usage of the frostwalker enchantment, like pillaring up from water.
*/
public final Setting assumeWalkOnWater = new Setting<>(false);
diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index cb6b0da3b..e1f3cf090 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -30,6 +30,7 @@ import baritone.utils.ToolSet;
import net.minecraft.block.*;
import net.minecraft.block.properties.PropertyBool;
import net.minecraft.block.state.IBlockState;
+import net.minecraft.enchantment.EnchantmentHelper;
import net.minecraft.init.Blocks;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.math.BlockPos;
@@ -366,6 +367,13 @@ public interface MovementHelper extends ActionCosts, Helper {
&& ((Integer) state.getValue(BlockLiquid.LEVEL)) == 0;
}
+ static boolean canUseFrostWalker(IPlayerContext ctx, BlockPos pos) {
+ IBlockState state = BlockStateInterface.get(ctx, pos);
+ return EnchantmentHelper.hasFrostWalkerEnchantment(ctx.player())
+ && (state.getBlock() == Blocks.WATER || state.getBlock() == Blocks.FLOWING_WATER)
+ && ((Integer) state.getValue(BlockLiquid.LEVEL)) == 0;
+ }
+
static boolean canPlaceAgainst(BlockStateInterface bsi, int x, int y, int z) {
return canPlaceAgainst(bsi, x, y, z, bsi.get0(x, y, z));
}
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDescend.java b/src/main/java/baritone/pathing/movement/movements/MovementDescend.java
index 716db3311..cf711836d 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementDescend.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementDescend.java
@@ -110,7 +110,7 @@ public class MovementDescend extends Movement {
if (destDown.getBlock() == Blocks.LADDER || destDown.getBlock() == Blocks.VINE) {
return;
}
- if (MovementHelper.canUseFrostWalker(context, destDown)) {
+ if (MovementHelper.canUseFrostWalker(context, destDown)) { // no need to check assumeWalkOnWater
return; // the water will freeze when we try to walk into it
}
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
index d8730b34d..268d7f932 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
@@ -30,6 +30,7 @@ import baritone.utils.BlockStateInterface;
import baritone.utils.pathing.MutableMoveResult;
import com.google.common.collect.ImmutableSet;
import net.minecraft.block.Block;
+import net.minecraft.block.BlockLiquid;
import net.minecraft.block.state.IBlockState;
import net.minecraft.client.entity.EntityPlayerSP;
import net.minecraft.init.Blocks;
@@ -117,6 +118,7 @@ public class MovementDiagonal extends Movement {
boolean ascend = false;
IBlockState destWalkOn;
boolean descend = false;
+ boolean frostWalker = false;
if (!MovementHelper.canWalkThrough(context.bsi, destX, y, destZ, destInto)) {
ascend = true;
if (!context.allowDiagonalAscend || !MovementHelper.canWalkThrough(context.bsi, x, y + 2, z) || !MovementHelper.canWalkOn(context.bsi, destX, y, destZ, destInto) || !MovementHelper.canWalkThrough(context.bsi, destX, y + 2, destZ)) {
@@ -125,9 +127,8 @@ public class MovementDiagonal extends Movement {
destWalkOn = destInto;
} else {
destWalkOn = context.get(destX, y - 1, destZ);
- if (!MovementHelper.canWalkOn(context.bsi, destX, y - 1, destZ, destWalkOn)
- && !MovementHelper.canUseFrostWalker(context, destWalkOn)
- ) {
+ frostWalker = MovementHelper.canUseFrostWalker(context, destWalkOn) && !(context.assumeWalkOnWater && context.getBlock(x, y - 1, z) instanceof BlockLiquid);
+ if (!MovementHelper.canWalkOn(context.bsi, destX, y - 1, destZ, destWalkOn) && !frostWalker) {
descend = true;
if (!context.allowDiagonalDescend || !MovementHelper.canWalkOn(context.bsi, destX, y - 2, destZ) || !MovementHelper.canWalkThrough(context.bsi, destX, y - 1, destZ, destWalkOn)) {
return;
@@ -138,8 +139,8 @@ public class MovementDiagonal extends Movement {
// For either possible soul sand, that affects half of our walking
if (destWalkOn.getBlock() == Blocks.SOUL_SAND) {
multiplier += (WALK_ONE_OVER_SOUL_SAND_COST - WALK_ONE_BLOCK_COST) / 2;
- } else if (!ascend && !descend && MovementHelper.canUseFrostWalker(context, destWalkOn)) {
- // frostwalker lets us walk on water without the penalty, but only works if we don't ascend or descend
+ } else if (frostWalker) {
+ // frostwalker lets us walk on water without the penalty
} else if (destWalkOn.getBlock() == Blocks.WATER) {
multiplier += context.walkOnWaterOnePenalty * SQRT_2;
}
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementParkour.java b/src/main/java/baritone/pathing/movement/movements/MovementParkour.java
index 2ea112bf3..abe4768ea 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementParkour.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementParkour.java
@@ -94,7 +94,8 @@ public class MovementParkour extends Movement {
if (standingOn.getBlock() == Blocks.VINE || standingOn.getBlock() == Blocks.LADDER || standingOn.getBlock() instanceof BlockStairs || MovementHelper.isBottomSlab(standingOn)) {
return;
}
- if (standingOn.getBlock() instanceof BlockLiquid && !MovementHelper.canUseFrostWalker(context, standingOn)) {
+ // we can't jump from (frozen) water with assumeWalkOnWater because we can't be sure it will be frozen
+ if (standingOn.getBlock() instanceof BlockLiquid && (!MovementHelper.canUseFrostWalker(context, standingOn) || context.assumeWalkOnWater)) {
return;
}
int maxJump;
@@ -138,6 +139,7 @@ public class MovementParkour extends Movement {
// check for flat landing position
IBlockState landingOn = context.bsi.get0(destX, y - 1, destZ);
// farmland needs to be canWalkOn otherwise farm can never work at all, but we want to specifically disallow ending a jump on farmland haha
+ // frostwalker works here because we can't jump from possibly unfrozen water
if ((landingOn.getBlock() != Blocks.FARMLAND && MovementHelper.canWalkOn(context.bsi, destX, y - 1, destZ, landingOn))
|| (Math.min(16, context.frostWalker + 2) >= i && MovementHelper.canUseFrostWalker(context, landingOn))
) {
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
index 1d15d0631..9eb05d46c 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
@@ -82,8 +82,9 @@ public class MovementTraverse extends Movement {
} else {
if (destOn.getBlock() == Blocks.SOUL_SAND) {
WC += (WALK_ONE_OVER_SOUL_SAND_COST - WALK_ONE_BLOCK_COST) / 2;
- } else if (destOn.getBlock() == Blocks.WATER && !MovementHelper.canUseFrostWalker(context, destOn)) {
- // with frostwalker we can walk on water without the penalty
+ } else if (MovementHelper.canUseFrostWalker(context, destOn) && !context.assumeWalkOnWater) {
+ // with frostwalker we can walk on water without the penalty, if we are sure we won't be using jesus
+ } else if (destOn.getBlock() == Blocks.WATER) {
WC += context.walkOnWaterOnePenalty;
}
if (srcDown == Blocks.SOUL_SAND) {
@@ -228,7 +229,7 @@ public class MovementTraverse extends Movement {
}
}
- boolean isTheBridgeBlockThere = MovementHelper.canWalkOn(ctx, positionToPlace) || ladder || EnchantmentHelper.hasFrostWalkerEnchantment(ctx.player());
+ boolean isTheBridgeBlockThere = MovementHelper.canWalkOn(ctx, positionToPlace) || ladder || MovementHelper.canUseFrostWalker(ctx, positionToPlace);
BlockPos feet = ctx.playerFeet();
if (feet.getY() != dest.getY() && !ladder) {
logDebug("Wrong Y coordinate");
From 96ba96ca6956bb25d49f98dc1acb0b46b26bcaef Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Mon, 29 Aug 2022 18:47:54 +0200
Subject: [PATCH 27/71] Fix some more edge cases
---
.../pathing/movement/movements/MovementDiagonal.java | 3 ++-
.../pathing/movement/movements/MovementTraverse.java | 7 +++++--
2 files changed, 7 insertions(+), 3 deletions(-)
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
index 268d7f932..fafc49824 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
@@ -127,7 +127,8 @@ public class MovementDiagonal extends Movement {
destWalkOn = destInto;
} else {
destWalkOn = context.get(destX, y - 1, destZ);
- frostWalker = MovementHelper.canUseFrostWalker(context, destWalkOn) && !(context.assumeWalkOnWater && context.getBlock(x, y - 1, z) instanceof BlockLiquid);
+ boolean standingOnABlock = !(context.getBlock(x, y - 1, z) instanceof BlockLiquid) || (!context.assumeWalkOnWater && !(context.getBlock(x, y, z) instanceof BlockLiquid));
+ frostWalker = standingOnABlock && MovementHelper.canUseFrostWalker(context, destWalkOn);
if (!MovementHelper.canWalkOn(context.bsi, destX, y - 1, destZ, destWalkOn) && !frostWalker) {
descend = true;
if (!context.allowDiagonalDescend || !MovementHelper.canWalkOn(context.bsi, destX, y - 2, destZ) || !MovementHelper.canWalkThrough(context.bsi, destX, y - 1, destZ, destWalkOn)) {
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
index 9eb05d46c..6e44ad62c 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
@@ -73,7 +73,10 @@ public class MovementTraverse extends Movement {
IBlockState pb1 = context.get(destX, y, destZ);
IBlockState destOn = context.get(destX, y - 1, destZ);
Block srcDown = context.getBlock(x, y - 1, z);
- if (MovementHelper.canWalkOn(context.bsi, destX, y - 1, destZ, destOn) || MovementHelper.canUseFrostWalker(context, destOn)) { //this is a walk, not a bridge
+ // if we are on water but are neither in water nor can stand on water we must have placed a block to get here
+ boolean standingOnABlock = !(srcDown instanceof BlockLiquid) || (!context.assumeWalkOnWater && !(context.getBlock(x, y, z) instanceof BlockLiquid));
+ boolean frostWalker = standingOnABlock && MovementHelper.canUseFrostWalker(context, destOn);
+ if (MovementHelper.canWalkOn(context.bsi, destX, y - 1, destZ, destOn) || frostWalker) { //this is a walk, not a bridge
double WC = WALK_ONE_BLOCK_COST;
boolean water = false;
if (MovementHelper.isWater(pb0.getBlock()) || MovementHelper.isWater(pb1.getBlock())) {
@@ -82,7 +85,7 @@ public class MovementTraverse extends Movement {
} else {
if (destOn.getBlock() == Blocks.SOUL_SAND) {
WC += (WALK_ONE_OVER_SOUL_SAND_COST - WALK_ONE_BLOCK_COST) / 2;
- } else if (MovementHelper.canUseFrostWalker(context, destOn) && !context.assumeWalkOnWater) {
+ } else if (frostWalker) {
// with frostwalker we can walk on water without the penalty, if we are sure we won't be using jesus
} else if (destOn.getBlock() == Blocks.WATER) {
WC += context.walkOnWaterOnePenalty;
From 78f1c45e13ed0dd2e5d7f8f13d9989bdd25a3bee Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Wed, 31 Aug 2022 23:39:09 +0200
Subject: [PATCH 28/71] Don't overshoot descends before using frostwalker
---
.../pathing/movement/movements/MovementDescend.java | 12 ++++++++++++
.../java/baritone/pathing/path/PathExecutor.java | 9 ++++++++-
2 files changed, 20 insertions(+), 1 deletion(-)
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDescend.java b/src/main/java/baritone/pathing/movement/movements/MovementDescend.java
index cf711836d..9ac00309f 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementDescend.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementDescend.java
@@ -44,6 +44,7 @@ import java.util.Set;
public class MovementDescend extends Movement {
private int numTicks = 0;
+ public boolean forceSafeMode = false;
public MovementDescend(IBaritone baritone, BetterBlockPos start, BetterBlockPos end) {
super(baritone, start, end, new BetterBlockPos[]{end.up(2), end.up(), end}, end.down());
@@ -53,6 +54,14 @@ public class MovementDescend extends Movement {
public void reset() {
super.reset();
numTicks = 0;
+ forceSafeMode = false;
+ }
+
+ /**
+ * Called by PathExecutor if needing safeMode can only be detected with knowledge about the next movement
+ */
+ public void forceSafeMode() {
+ forceSafeMode = true;
}
@Override
@@ -252,6 +261,9 @@ public class MovementDescend extends Movement {
}
public boolean safeMode() {
+ if (forceSafeMode) {
+ return true;
+ }
// (dest - src) + dest is offset 1 more in the same direction
// so it's the block we'd need to worry about running into if we decide to sprint straight through this descend
BlockPos into = dest.subtract(src.down()).add(dest);
diff --git a/src/main/java/baritone/pathing/path/PathExecutor.java b/src/main/java/baritone/pathing/path/PathExecutor.java
index 17fa788db..37cdcaa46 100644
--- a/src/main/java/baritone/pathing/path/PathExecutor.java
+++ b/src/main/java/baritone/pathing/path/PathExecutor.java
@@ -380,13 +380,20 @@ public class PathExecutor implements IPathExecutor, Helper {
// however, descend and ascend don't request sprinting, because they don't know the context of what movement comes after it
if (current instanceof MovementDescend) {
+ IMovement next = path.movements().get(pathPosition + 1);
+ if (next instanceof MovementTraverse) {
+ if (MovementHelper.canUseFrostWalker(ctx, next.getDest().down())) {
+ // if we are going to continue straight onto the water with frostwalker feet.equals(dest) must hold, otherwise we don't want to waste time
+ // Since MovementDescend can't know the direction of the next movement we have to tell it
+ ((MovementDescend) current).forceSafeMode(); // keep this out of onTick, even if that means a tick of delay before it has an effect
+ }
+ }
if (((MovementDescend) current).safeMode() && !((MovementDescend) current).skipToAscend()) {
logDebug("Sprinting would be unsafe");
return false;
}
if (pathPosition < path.length() - 2) {
- IMovement next = path.movements().get(pathPosition + 1);
if (next instanceof MovementAscend && current.getDirection().up().equals(next.getDirection().down())) {
// a descend then an ascend in the same direction
pathPosition++;
From af95f7713499029ee9d09f9d05a33d78b85a4b26 Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Thu, 1 Sep 2022 00:56:34 +0200
Subject: [PATCH 29/71] Fix OOB and check for direction and include parkour
---
.../movement/movements/MovementTraverse.java | 2 +-
.../baritone/pathing/path/PathExecutor.java | 18 +++++++++++++-----
2 files changed, 14 insertions(+), 6 deletions(-)
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
index 6e44ad62c..66fed66fd 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
@@ -148,7 +148,7 @@ public class MovementTraverse extends Movement {
if (srcDown == Blocks.SOUL_SAND || (srcDown instanceof BlockSlab && !((BlockSlab) srcDown).isDouble())) {
return COST_INF; // can't sneak and backplace against soul sand or half slabs (regardless of whether it's top half or bottom half) =/
}
- if (srcDown == Blocks.FLOWING_WATER || srcDown == Blocks.WATER) {
+ if (!standingOnABlock) { // standing on water / swimming
return COST_INF; // this is obviously impossible
}
WC = WC * (SNEAK_ONE_BLOCK_COST / WALK_ONE_BLOCK_COST);//since we are sneak backplacing, we are sneaking lol
diff --git a/src/main/java/baritone/pathing/path/PathExecutor.java b/src/main/java/baritone/pathing/path/PathExecutor.java
index 37cdcaa46..01b849c8d 100644
--- a/src/main/java/baritone/pathing/path/PathExecutor.java
+++ b/src/main/java/baritone/pathing/path/PathExecutor.java
@@ -380,12 +380,19 @@ public class PathExecutor implements IPathExecutor, Helper {
// however, descend and ascend don't request sprinting, because they don't know the context of what movement comes after it
if (current instanceof MovementDescend) {
- IMovement next = path.movements().get(pathPosition + 1);
- if (next instanceof MovementTraverse) {
+ if (pathPosition < path.length() - 2) {
+ // keep this out of onTick, even if that means a tick of delay before it has an effect
+ IMovement next = path.movements().get(pathPosition + 1);
if (MovementHelper.canUseFrostWalker(ctx, next.getDest().down())) {
- // if we are going to continue straight onto the water with frostwalker feet.equals(dest) must hold, otherwise we don't want to waste time
- // Since MovementDescend can't know the direction of the next movement we have to tell it
- ((MovementDescend) current).forceSafeMode(); // keep this out of onTick, even if that means a tick of delay before it has an effect
+ // frostwalker only works if you cross the edge of the block on ground so in some cases we may not overshoot
+ // Since MovementDescend can't know the next movement we have to tell it
+ if (next instanceof MovementTraverse || next instanceof MovementParkour) {
+ boolean couldPlaceInstead = Baritone.settings().allowPlace.value && behavior.baritone.getInventoryBehavior().hasGenericThrowaway() && next instanceof MovementParkour; // traverse doesn't react fast enough
+ boolean sameFlatDirection = current.getDirection().up().crossProduct(next.getDirection()).equals(BlockPos.ORIGIN); // here's why you learn maths in school
+ if (sameFlatDirection && !couldPlaceInstead) {
+ ((MovementDescend) current).forceSafeMode();
+ }
+ }
}
}
if (((MovementDescend) current).safeMode() && !((MovementDescend) current).skipToAscend()) {
@@ -394,6 +401,7 @@ public class PathExecutor implements IPathExecutor, Helper {
}
if (pathPosition < path.length() - 2) {
+ IMovement next = path.movements().get(pathPosition + 1);
if (next instanceof MovementAscend && current.getDirection().up().equals(next.getDirection().down())) {
// a descend then an ascend in the same direction
pathPosition++;
From 9ffe4f2c257b572690163900a7ec4f53babee64a Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Thu, 1 Sep 2022 02:17:18 +0200
Subject: [PATCH 30/71] Fix parkour with frostwalker with/without throwaways
* Placing throwaways with allowPlace disabled
* Failing without throwaways
---
.../pathing/movement/movements/MovementParkour.java | 8 +++++++-
1 file changed, 7 insertions(+), 1 deletion(-)
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementParkour.java b/src/main/java/baritone/pathing/movement/movements/MovementParkour.java
index abe4768ea..32753c5d9 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementParkour.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementParkour.java
@@ -17,6 +17,7 @@
package baritone.pathing.movement.movements;
+import baritone.Baritone;
import baritone.api.IBaritone;
import baritone.api.pathing.movement.MovementStatus;
import baritone.api.utils.BetterBlockPos;
@@ -272,7 +273,12 @@ public class MovementParkour extends Movement {
}
} else if (!ctx.playerFeet().equals(src)) {
if (ctx.playerFeet().equals(src.offset(direction)) || ctx.player().posY - src.y > 0.0001) {
- if (!MovementHelper.canWalkOn(ctx, dest.down()) && !ctx.player().onGround && MovementHelper.attemptToPlaceABlock(state, baritone, dest.down(), true, false) == PlaceResult.READY_TO_PLACE) {
+ if (Baritone.settings().allowPlace.value
+ && ((Baritone) baritone).getInventoryBehavior().hasGenericThrowaway()
+ && !MovementHelper.canWalkOn(ctx, dest.down())
+ && !ctx.player().onGround
+ && MovementHelper.attemptToPlaceABlock(state, baritone, dest.down(), true, false) == PlaceResult.READY_TO_PLACE
+ ) {
// go in the opposite order to check DOWN before all horizontals -- down is preferable because you don't have to look to the side while in midair, which could mess up the trajectory
state.setInput(Input.CLICK_RIGHT, true);
}
From 45c0b381562f7fae7d146be19c0a9adbf76af76e Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Fri, 30 Sep 2022 18:04:34 +0200
Subject: [PATCH 31/71] Fix jumping from packplaced blocks on water
Not having frostwalker means that we must have replaced the water with a throwaway, not that we are standing on water
---
.../baritone/pathing/movement/movements/MovementParkour.java | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementParkour.java b/src/main/java/baritone/pathing/movement/movements/MovementParkour.java
index 32753c5d9..597f0d72f 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementParkour.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementParkour.java
@@ -96,7 +96,7 @@ public class MovementParkour extends Movement {
return;
}
// we can't jump from (frozen) water with assumeWalkOnWater because we can't be sure it will be frozen
- if (standingOn.getBlock() instanceof BlockLiquid && (!MovementHelper.canUseFrostWalker(context, standingOn) || context.assumeWalkOnWater)) {
+ if (context.assumeWalkOnWater && standingOn.getBlock() instanceof BlockLiquid) {
return;
}
int maxJump;
From c14be17e53b71e01ae18e4c1f4a1db3601b325c1 Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Fri, 30 Sep 2022 22:27:32 +0200
Subject: [PATCH 32/71] Move this to a helper method and add missing cases
---
.../pathing/movement/MovementHelper.java | 20 +++++++++++++++++++
.../movement/movements/MovementDiagonal.java | 2 +-
.../movement/movements/MovementTraverse.java | 3 +--
3 files changed, 22 insertions(+), 3 deletions(-)
diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index e1f3cf090..b8c4c034d 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -374,6 +374,26 @@ public interface MovementHelper extends ActionCosts, Helper {
&& ((Integer) state.getValue(BlockLiquid.LEVEL)) == 0;
}
+ /**
+ * If movements make us stand/walk on this block, will it have a top to walk on?
+ */
+ static boolean mustBeSolidToWalkOn(CalculationContext context, int x, int y, int z, IBlockState state) {
+ Block block = state.getBlock();
+ if (block == Blocks.LADDER || block == Blocks.VINE) {
+ return false;
+ }
+ if (block instanceof BlockLiquid) {
+ if (context.assumeWalkOnWater) {
+ return false;
+ }
+ Block blockAbove = context.getBlock(x, y+1, z);
+ if (blockAbove instanceof BlockLiquid) {
+ return false;
+ }
+ }
+ return true;
+ }
+
static boolean canPlaceAgainst(BlockStateInterface bsi, int x, int y, int z) {
return canPlaceAgainst(bsi, x, y, z, bsi.get0(x, y, z));
}
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
index fafc49824..8436e3cab 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
@@ -127,7 +127,7 @@ public class MovementDiagonal extends Movement {
destWalkOn = destInto;
} else {
destWalkOn = context.get(destX, y - 1, destZ);
- boolean standingOnABlock = !(context.getBlock(x, y - 1, z) instanceof BlockLiquid) || (!context.assumeWalkOnWater && !(context.getBlock(x, y, z) instanceof BlockLiquid));
+ boolean standingOnABlock = MovementHelper.mustBeSolidToWalkOn(context, x, y-1, z, context.get(x, y-1, z));
frostWalker = standingOnABlock && MovementHelper.canUseFrostWalker(context, destWalkOn);
if (!MovementHelper.canWalkOn(context.bsi, destX, y - 1, destZ, destWalkOn) && !frostWalker) {
descend = true;
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
index 66fed66fd..368dbbf8b 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
@@ -73,8 +73,7 @@ public class MovementTraverse extends Movement {
IBlockState pb1 = context.get(destX, y, destZ);
IBlockState destOn = context.get(destX, y - 1, destZ);
Block srcDown = context.getBlock(x, y - 1, z);
- // if we are on water but are neither in water nor can stand on water we must have placed a block to get here
- boolean standingOnABlock = !(srcDown instanceof BlockLiquid) || (!context.assumeWalkOnWater && !(context.getBlock(x, y, z) instanceof BlockLiquid));
+ boolean standingOnABlock = MovementHelper.mustBeSolidToWalkOn(context, x, y-1, z, context.get(x, y-1, z));
boolean frostWalker = standingOnABlock && MovementHelper.canUseFrostWalker(context, destOn);
if (MovementHelper.canWalkOn(context.bsi, destX, y - 1, destZ, destOn) || frostWalker) { //this is a walk, not a bridge
double WC = WALK_ONE_BLOCK_COST;
From 3da5bbd2674fa1eb85ea30f5ba736e78b14b1ff1 Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Fri, 30 Sep 2022 22:38:21 +0200
Subject: [PATCH 33/71] Don't pillar from carpet/lilypad on water
---
.../baritone/pathing/movement/movements/MovementPillar.java | 4 ++++
1 file changed, 4 insertions(+)
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementPillar.java b/src/main/java/baritone/pathing/movement/movements/MovementPillar.java
index b9d599334..1a54c104c 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementPillar.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementPillar.java
@@ -101,6 +101,10 @@ public class MovementPillar extends Movement {
// if we're standing on water and assumeWalkOnWater is false, we must have ascended to here, or sneak backplaced, so it is possible to pillar again
return COST_INF;
}
+ if (fromDown.getBlock() instanceof BlockLiquid && (from == Blocks.WATERLILY || from == Blocks.CARPET)) {
+ // to ascend here we'd have to break the block we are standing on
+ return COST_INF;
+ }
double hardness = MovementHelper.getMiningDurationTicks(context, x, y + 2, z, toBreak, true);
if (hardness >= COST_INF) {
return COST_INF;
From eb697b7a17071b80edab5f935849e9f1eea3d511 Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Fri, 30 Sep 2022 22:40:23 +0200
Subject: [PATCH 34/71] Fix costs when assumeWalkOnWater stops us from relying
on frostWalker
---
.../baritone/pathing/movement/movements/MovementDiagonal.java | 1 +
.../baritone/pathing/movement/movements/MovementTraverse.java | 2 +-
2 files changed, 2 insertions(+), 1 deletion(-)
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
index 8436e3cab..ba8893a3a 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
@@ -135,6 +135,7 @@ public class MovementDiagonal extends Movement {
return;
}
}
+ frostWalker &= !context.assumeWalkOnWater; // do this after checking for descends because jesus can't prevent the water from freezing, it just prevents us from relying on the water freezing
}
double multiplier = WALK_ONE_BLOCK_COST;
// For either possible soul sand, that affects half of our walking
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
index 368dbbf8b..b3a865014 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
@@ -74,7 +74,7 @@ public class MovementTraverse extends Movement {
IBlockState destOn = context.get(destX, y - 1, destZ);
Block srcDown = context.getBlock(x, y - 1, z);
boolean standingOnABlock = MovementHelper.mustBeSolidToWalkOn(context, x, y-1, z, context.get(x, y-1, z));
- boolean frostWalker = standingOnABlock && MovementHelper.canUseFrostWalker(context, destOn);
+ boolean frostWalker = standingOnABlock && !context.assumeWalkOnWater && MovementHelper.canUseFrostWalker(context, destOn);
if (MovementHelper.canWalkOn(context.bsi, destX, y - 1, destZ, destOn) || frostWalker) { //this is a walk, not a bridge
double WC = WALK_ONE_BLOCK_COST;
boolean water = false;
From 43ee86b4fe6a164b3f7719e00cfa1f147fddb0a4 Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Fri, 30 Sep 2022 22:41:09 +0200
Subject: [PATCH 35/71] Don't try backplacing against water under
carpet/lilypad
---
.../baritone/pathing/movement/movements/MovementTraverse.java | 3 +++
1 file changed, 3 insertions(+)
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
index b3a865014..1d6dd8715 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
@@ -150,6 +150,9 @@ public class MovementTraverse extends Movement {
if (!standingOnABlock) { // standing on water / swimming
return COST_INF; // this is obviously impossible
}
+ if (srcDown instanceof BlockLiquid && (context.getBlock(x,y,z) == Blocks.WATERLILY || context.getBlock(x,y,z) == Blocks.CARPET)) {
+ return COST_INF; // we can stand on these but can't place against them
+ }
WC = WC * (SNEAK_ONE_BLOCK_COST / WALK_ONE_BLOCK_COST);//since we are sneak backplacing, we are sneaking lol
return WC + placeCost + hardness1 + hardness2;
}
From fb814e912dadf3f6e34358354a86b54674103081 Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Fri, 30 Sep 2022 23:59:49 +0200
Subject: [PATCH 36/71] Don't try parkouring out of water
---
.../baritone/pathing/movement/movements/MovementParkour.java | 3 +++
1 file changed, 3 insertions(+)
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementParkour.java b/src/main/java/baritone/pathing/movement/movements/MovementParkour.java
index 597f0d72f..6a94e47fa 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementParkour.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementParkour.java
@@ -99,6 +99,9 @@ public class MovementParkour extends Movement {
if (context.assumeWalkOnWater && standingOn.getBlock() instanceof BlockLiquid) {
return;
}
+ if (context.getBlock(x, y, z) instanceof BlockLiquid) {
+ return; // can't jump out of water
+ }
int maxJump;
if (standingOn.getBlock() == Blocks.SOUL_SAND) {
maxJump = 2; // 1 block gap
From ba3ca47f8c454a8c9ed34d6da66d1b63bf7acf37 Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Sun, 23 Oct 2022 01:42:31 +0200
Subject: [PATCH 37/71] =?UTF-8?q?=E2=9C=A8=20Add=20buildIgnoreProperties?=
=?UTF-8?q?=20setting?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
src/api/java/baritone/api/Settings.java | 6 ++++++
src/main/java/baritone/process/BuilderProcess.java | 13 ++++++++++---
2 files changed, 16 insertions(+), 3 deletions(-)
diff --git a/src/api/java/baritone/api/Settings.java b/src/api/java/baritone/api/Settings.java
index 897182898..267fe7822 100644
--- a/src/api/java/baritone/api/Settings.java
+++ b/src/api/java/baritone/api/Settings.java
@@ -279,6 +279,12 @@ public final class Settings {
*/
public final Setting buildIgnoreDirection = new Setting<>(false);
+ /**
+ * A list of names of block properties the builder will ignore.
+ */
+ public final Setting> buildIgnoreProperties = new Setting<>(new ArrayList<>(Arrays.asList(
+ )));
+
/**
* If this setting is true, Baritone will never break a block that is adjacent to an unsupported falling block.
*
diff --git a/src/main/java/baritone/process/BuilderProcess.java b/src/main/java/baritone/process/BuilderProcess.java
index c1c0cb1d9..2d7714d9e 100644
--- a/src/main/java/baritone/process/BuilderProcess.java
+++ b/src/main/java/baritone/process/BuilderProcess.java
@@ -874,14 +874,21 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
BlockTrapDoor.OPEN, BlockTrapDoor.HALF
);
- private boolean sameWithoutOrientation(IBlockState first, IBlockState second) {
+ private boolean sameBlockstate(IBlockState first, IBlockState second) {
if (first.getBlock() != second.getBlock()) {
return false;
}
+ boolean ignoreDirection = Baritone.settings().buildIgnoreDirection.value;
+ List ignoredProps = Baritone.settings().buildIgnoreProperties.value;
+ if (!ignoreDirection && ignoredProps.isEmpty()) {
+ return first.equals(second); // early return if no properties are being ignored
+ }
ImmutableMap, Comparable> map1 = first.getProperties();
ImmutableMap, Comparable> map2 = second.getProperties();
for (IProperty prop : map1.keySet()) {
- if (map1.get(prop) != map2.get(prop) && !orientationProps.contains(prop)) {
+ if (map1.get(prop) != map2.get(prop)
+ && !(ignoreDirection && orientationProps.contains(prop))
+ && !ignoredProps.contains(prop.getName())) {
return false;
}
}
@@ -913,7 +920,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
if (current.equals(desired)) {
return true;
}
- return Baritone.settings().buildIgnoreDirection.value && sameWithoutOrientation(current, desired);
+ return sameBlockstate(current, desired);
}
public class BuilderCalculationContext extends CalculationContext {
From 1cd2fb5b18203b7fee4f8e1c71a53326e6b7e2ea Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Mon, 24 Oct 2022 22:49:12 +0200
Subject: [PATCH 38/71] Reliably clear keys when paused
---
.../java/baritone/command/defaults/ExecutionControlCommands.java | 1 +
1 file changed, 1 insertion(+)
diff --git a/src/main/java/baritone/command/defaults/ExecutionControlCommands.java b/src/main/java/baritone/command/defaults/ExecutionControlCommands.java
index eaab75286..6f6293ccd 100644
--- a/src/main/java/baritone/command/defaults/ExecutionControlCommands.java
+++ b/src/main/java/baritone/command/defaults/ExecutionControlCommands.java
@@ -56,6 +56,7 @@ public class ExecutionControlCommands {
@Override
public PathingCommand onTick(boolean calcFailed, boolean isSafeToCancel) {
+ baritone.getInputOverrideHandler().clearAllKeys();
return new PathingCommand(null, PathingCommandType.REQUEST_PAUSE);
}
From 3cef7a7911d45c94a1344239ab6895b5c7578bb8 Mon Sep 17 00:00:00 2001
From: rycbar0 <100363533+rycbar0@users.noreply.github.com>
Date: Wed, 26 Oct 2022 23:09:23 +0200
Subject: [PATCH 39/71] formula error
---
.../utils/schematic/format/defaults/LitematicaSchematic.java | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/main/java/baritone/utils/schematic/format/defaults/LitematicaSchematic.java b/src/main/java/baritone/utils/schematic/format/defaults/LitematicaSchematic.java
index 84b9b86e2..c2857bc2d 100644
--- a/src/main/java/baritone/utils/schematic/format/defaults/LitematicaSchematic.java
+++ b/src/main/java/baritone/utils/schematic/format/defaults/LitematicaSchematic.java
@@ -136,7 +136,7 @@ public final class LitematicaSchematic extends StaticSchematic {
* @return amount of bits used to encode a block.
*/
private static int getBitsPerBlock(int amountOfBlockTypes) {
- return (int) Math.floor((Math.log(amountOfBlockTypes)) / Math.log(2)) + 1;
+ return (int) Math.max(2,Math.ceil(Math.log(amountOfBlockTypes) / Math.log(2)));
}
/**
From eabd1150b0a619f7e2adada9dfbd837613bf9414 Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Tue, 22 Nov 2022 15:15:33 +0100
Subject: [PATCH 40/71] Allow breaking next to some liquids
---
src/api/java/baritone/api/Settings.java | 7 +++++++
.../baritone/pathing/movement/MovementHelper.java | 13 ++++++++++++-
2 files changed, 19 insertions(+), 1 deletion(-)
diff --git a/src/api/java/baritone/api/Settings.java b/src/api/java/baritone/api/Settings.java
index 267fe7822..cd3a0a805 100644
--- a/src/api/java/baritone/api/Settings.java
+++ b/src/api/java/baritone/api/Settings.java
@@ -107,6 +107,13 @@ public final class Settings {
*/
public final Setting walkOnWaterOnePenalty = new Setting<>(3D);
+ /**
+ * Don't allow breaking blocks next to liquids.
+ *
+ * Enable if you have mods adding custom fluid physics.
+ */
+ public final Setting strictLiquidCheck = new Setting<>(false);
+
/**
* Allow Baritone to fall arbitrary distances and place a water bucket beneath it.
* Reliability: questionable.
diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index dd0ddff48..d1cea8dc9 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -77,7 +77,18 @@ public interface MovementHelper extends ActionCosts, Helper {
&& BlockFalling.canFallThrough(bsi.get0(x, y - 1, z))) { // and if it would fall (i.e. it's unsupported)
return true; // dont break a block that is adjacent to unsupported gravel because it can cause really weird stuff
}
- return block instanceof BlockLiquid;
+ if (block instanceof BlockLiquid) {
+ if (directlyAbove || Baritone.settings().strictLiquidCheck.value) {
+ return true;
+ }
+ int level = state.getValue(BlockLiquid.LEVEL);
+ if (level == 0) {
+ return true; // source blocks like to flow horizontally
+ }
+ // everything else will prefer flowing down
+ return !(bsi.get0(x, y - 1, z).getBlock() instanceof BlockLiquid); // assume everything is in a static state
+ }
+ return false;
}
static boolean canWalkThrough(IPlayerContext ctx, BetterBlockPos pos) {
From e1095962a1b2854dd65003959e17e5f812fad7e3 Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Mon, 28 Nov 2022 23:07:30 +0100
Subject: [PATCH 41/71] Fix Registry.unregister
---
src/api/java/baritone/api/command/registry/Registry.java | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/api/java/baritone/api/command/registry/Registry.java b/src/api/java/baritone/api/command/registry/Registry.java
index 067791690..b571484b7 100644
--- a/src/api/java/baritone/api/command/registry/Registry.java
+++ b/src/api/java/baritone/api/command/registry/Registry.java
@@ -84,7 +84,7 @@ public class Registry {
* @param entry The entry to unregister.
*/
public void unregister(V entry) {
- if (registered(entry)) {
+ if (!registered(entry)) {
return;
}
_entries.remove(entry);
From e09127eadf3efe6aee9afd56183c902181737c57 Mon Sep 17 00:00:00 2001
From: Wagyourtail
Date: Sat, 10 Dec 2022 16:35:51 -0700
Subject: [PATCH 42/71] allowBreakAnyway should let mining happen
---
.../java/baritone/process/MineProcess.java | 25 ++++++++++++++-----
1 file changed, 19 insertions(+), 6 deletions(-)
diff --git a/src/main/java/baritone/process/MineProcess.java b/src/main/java/baritone/process/MineProcess.java
index 1ec47cd92..08a6791b6 100644
--- a/src/main/java/baritone/process/MineProcess.java
+++ b/src/main/java/baritone/process/MineProcess.java
@@ -102,10 +102,17 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
return null;
}
}
+
if (!Baritone.settings().allowBreak.value) {
- logDirect("Unable to mine when allowBreak is false!");
- cancel();
- return null;
+ this.filter = new BlockOptionalMetaLookup(filter.blocks()
+ .stream()
+ .filter(e -> Baritone.settings().allowBreakAnyway.value.contains(e.getBlock()))
+ .toArray(BlockOptionalMeta[]::new));
+ if (this.filter.blocks().isEmpty()) {
+ logDirect("Unable to mine when allowBreak is false!");
+ cancel();
+ return null;
+ }
}
updateLoucaSystem();
int mineGoalUpdateInterval = Baritone.settings().mineGoalUpdateInterval.value;
@@ -467,9 +474,15 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
public void mine(int quantity, BlockOptionalMetaLookup filter) {
this.filter = filter;
if (filter != null && !Baritone.settings().allowBreak.value) {
- logDirect("Unable to mine when allowBreak is false!");
- this.mine(quantity, (BlockOptionalMetaLookup) null);
- return;
+ this.filter = new BlockOptionalMetaLookup(filter.blocks()
+ .stream()
+ .filter(e -> Baritone.settings().allowBreakAnyway.value.contains(e.getBlock()))
+ .toArray(BlockOptionalMeta[]::new));
+ if (this.filter.blocks().isEmpty()) {
+ logDirect("Unable to mine when allowBreak is false!");
+ this.mine(quantity, (BlockOptionalMetaLookup) null);
+ return;
+ }
}
this.desiredQuantity = quantity;
this.knownOreLocations = new ArrayList<>();
From 85087ce04a9130a92059732ca7046be3d39c9f29 Mon Sep 17 00:00:00 2001
From: Wagyourtail
Date: Sat, 10 Dec 2022 19:25:57 -0700
Subject: [PATCH 43/71] smarter filter filtering
---
.../java/baritone/process/MineProcess.java | 59 +++++++++++--------
1 file changed, 36 insertions(+), 23 deletions(-)
diff --git a/src/main/java/baritone/process/MineProcess.java b/src/main/java/baritone/process/MineProcess.java
index 08a6791b6..7666ec7c5 100644
--- a/src/main/java/baritone/process/MineProcess.java
+++ b/src/main/java/baritone/process/MineProcess.java
@@ -103,17 +103,6 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
}
}
- if (!Baritone.settings().allowBreak.value) {
- this.filter = new BlockOptionalMetaLookup(filter.blocks()
- .stream()
- .filter(e -> Baritone.settings().allowBreakAnyway.value.contains(e.getBlock()))
- .toArray(BlockOptionalMeta[]::new));
- if (this.filter.blocks().isEmpty()) {
- logDirect("Unable to mine when allowBreak is false!");
- cancel();
- return null;
- }
- }
updateLoucaSystem();
int mineGoalUpdateInterval = Baritone.settings().mineGoalUpdateInterval.value;
List curr = new ArrayList<>(knownOreLocations);
@@ -122,7 +111,7 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
Baritone.getExecutor().execute(() -> rescan(curr, context));
}
if (Baritone.settings().legitMine.value) {
- addNearby();
+ if (!addNearby()) return null;
}
Optional shaft = curr.stream()
.filter(pos -> pos.getX() == ctx.playerFeet().getX() && pos.getZ() == ctx.playerFeet().getZ())
@@ -183,6 +172,11 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
}
private PathingCommand updateGoal() {
+ BlockOptionalMetaLookup filter = filterFilter();
+ if (filter == null) {
+ return null;
+ }
+
boolean legit = Baritone.settings().legitMine.value;
List locs = knownOreLocations;
if (!locs.isEmpty()) {
@@ -227,6 +221,7 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
}
private void rescan(List already, CalculationContext context) {
+ BlockOptionalMetaLookup filter = filterFilter();
if (filter == null) {
return;
}
@@ -376,11 +371,18 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
return prune(ctx, locs, filter, max, blacklist, dropped);
}
- private void addNearby() {
+ private boolean addNearby() {
List dropped = droppedItemsScan();
knownOreLocations.addAll(dropped);
BlockPos playerFeet = ctx.playerFeet();
BlockStateInterface bsi = new BlockStateInterface(ctx);
+
+
+ BlockOptionalMetaLookup filter = filterFilter();
+ if (filter == null) {
+ return false;
+ }
+
int searchDist = 10;
double fakedBlockReachDistance = 20; // at least 10 * sqrt(3) with some extra space to account for positioning within the block
for (int x = playerFeet.getX() - searchDist; x <= playerFeet.getX() + searchDist; x++) {
@@ -398,6 +400,7 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
}
}
knownOreLocations = prune(new CalculationContext(baritone), knownOreLocations, filter, ORE_LOCATIONS_COUNT, blacklist, dropped);
+ return true;
}
private static List prune(CalculationContext ctx, List locs2, BlockOptionalMetaLookup filter, int max, List blacklist, List dropped) {
@@ -473,16 +476,8 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
@Override
public void mine(int quantity, BlockOptionalMetaLookup filter) {
this.filter = filter;
- if (filter != null && !Baritone.settings().allowBreak.value) {
- this.filter = new BlockOptionalMetaLookup(filter.blocks()
- .stream()
- .filter(e -> Baritone.settings().allowBreakAnyway.value.contains(e.getBlock()))
- .toArray(BlockOptionalMeta[]::new));
- if (this.filter.blocks().isEmpty()) {
- logDirect("Unable to mine when allowBreak is false!");
- this.mine(quantity, (BlockOptionalMetaLookup) null);
- return;
- }
+ if (this.filterFilter() == null) {
+ this.filter = null;
}
this.desiredQuantity = quantity;
this.knownOreLocations = new ArrayList<>();
@@ -494,4 +489,22 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
rescan(new ArrayList<>(), new CalculationContext(baritone));
}
}
+
+ private BlockOptionalMetaLookup filterFilter() {
+ if (this.filter == null) {
+ return null;
+ }
+ if (!Baritone.settings().allowBreak.value) {
+ BlockOptionalMetaLookup f = new BlockOptionalMetaLookup(this.filter.blocks()
+ .stream()
+ .filter(e -> Baritone.settings().allowBreakAnyway.value.contains(e.getBlock()))
+ .toArray(BlockOptionalMeta[]::new));
+ if (f.blocks().isEmpty()) {
+ logDirect("Unable to mine when allowBreak is false and target block is not in allowBreakAnyway!");
+ return null;
+ }
+ return f;
+ }
+ return filter;
+ }
}
From ea1914a24816ae57daa925132cafce4f7007edc8 Mon Sep 17 00:00:00 2001
From: Wagyourtail
Date: Sat, 10 Dec 2022 20:12:51 -0700
Subject: [PATCH 44/71] missed a spot
---
src/main/java/baritone/process/MineProcess.java | 5 ++++-
1 file changed, 4 insertions(+), 1 deletion(-)
diff --git a/src/main/java/baritone/process/MineProcess.java b/src/main/java/baritone/process/MineProcess.java
index 7666ec7c5..395e99d9a 100644
--- a/src/main/java/baritone/process/MineProcess.java
+++ b/src/main/java/baritone/process/MineProcess.java
@@ -111,7 +111,10 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
Baritone.getExecutor().execute(() -> rescan(curr, context));
}
if (Baritone.settings().legitMine.value) {
- if (!addNearby()) return null;
+ if (!addNearby()) {
+ cancel();
+ return null;
+ }
}
Optional shaft = curr.stream()
.filter(pos -> pos.getX() == ctx.playerFeet().getX() && pos.getZ() == ctx.playerFeet().getZ())
From d157756d9438566da4250eb3f26923f7b2d8e639 Mon Sep 17 00:00:00 2001
From: Warpten
Date: Mon, 12 Dec 2022 01:08:49 +0100
Subject: [PATCH 45/71] Improve handling spaces in paths during proguard pass
---
.../java/baritone/gradle/task/ProguardTask.java | 14 ++++++++++----
1 file changed, 10 insertions(+), 4 deletions(-)
diff --git a/buildSrc/src/main/java/baritone/gradle/task/ProguardTask.java b/buildSrc/src/main/java/baritone/gradle/task/ProguardTask.java
index 01e561775..1789435f7 100644
--- a/buildSrc/src/main/java/baritone/gradle/task/ProguardTask.java
+++ b/buildSrc/src/main/java/baritone/gradle/task/ProguardTask.java
@@ -209,8 +209,8 @@ public class ProguardTask extends BaritoneGradleTask {
// Setup the template that will be used to derive the API and Standalone configs
List template = Files.readAllLines(getTemporaryFile(PROGUARD_CONFIG_DEST));
- template.add(0, "-injars " + this.artifactPath.toString());
- template.add(1, "-outjars " + this.getTemporaryFile(PROGUARD_EXPORT_PATH));
+ template.add(0, "-injars '" + this.artifactPath.toString() + "'");
+ template.add(1, "-outjars '" + this.getTemporaryFile(PROGUARD_EXPORT_PATH) + "'");
// Acquire the RT jar using "java -verbose". This doesn't work on Java 9+
Process p = new ProcessBuilder(this.getJavaBinPathForProguard(), "-verbose").start();
@@ -405,9 +405,15 @@ public class ProguardTask extends BaritoneGradleTask {
Files.delete(this.proguardOut);
}
- Path proguardJar = getTemporaryFile(PROGUARD_JAR);
+ // Make paths relative to work directory; fixes spaces in path to config, @"" doesn't work
+ Path workingDirectory = getTemporaryFile("");
+ Path proguardJar = workingDirectory.relativize(getTemporaryFile(PROGUARD_JAR));
+ config = workingDirectory.relativize(config);
+
+ // Honestly, if you still have spaces in your path at this point, you're SOL.
+
Process p = new ProcessBuilder("java", "-jar", proguardJar.toString(), "@" + config.toString())
- .directory(getTemporaryFile("").toFile()) // Set the working directory to the temporary folder]
+ .directory(workingDirectory.toFile()) // Set the working directory to the temporary folder]
.start();
// We can't do output inherit process I/O with gradle for some reason and have it work, so we have to do this
From e59bf9ab97ded964c78739788a61c2ed9144dee6 Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Fri, 30 Dec 2022 16:09:45 +0100
Subject: [PATCH 46/71] Grab block only once
---
.../baritone/pathing/movement/movements/MovementTraverse.java | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
index 43386c4b3..bc91ee17f 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
@@ -150,7 +150,8 @@ public class MovementTraverse extends Movement {
if (!standingOnABlock) { // standing on water / swimming
return COST_INF; // this is obviously impossible
}
- if (srcDown instanceof BlockLiquid && (context.getBlock(x,y,z) == Blocks.WATERLILY || context.getBlock(x,y,z) == Blocks.CARPET)) {
+ Block blockSrc = context.getBlock(x, y, z);
+ if (srcDown instanceof BlockLiquid && (blockSrc == Blocks.WATERLILY || blockSrc == Blocks.CARPET)) {
return COST_INF; // we can stand on these but can't place against them
}
WC = WC * (SNEAK_ONE_BLOCK_COST / WALK_ONE_BLOCK_COST);//since we are sneak backplacing, we are sneaking lol
From f76283ebfeb5bba7d53d76f727335de665131951 Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Tue, 3 Jan 2023 00:50:56 +0100
Subject: [PATCH 47/71] Remove unused imports
---
.../baritone/pathing/movement/movements/MovementDescend.java | 1 -
.../baritone/pathing/movement/movements/MovementDiagonal.java | 1 -
.../baritone/pathing/movement/movements/MovementTraverse.java | 1 -
3 files changed, 3 deletions(-)
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDescend.java b/src/main/java/baritone/pathing/movement/movements/MovementDescend.java
index 52f102b2a..d36843cdd 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementDescend.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementDescend.java
@@ -32,7 +32,6 @@ import baritone.utils.pathing.MutableMoveResult;
import com.google.common.collect.ImmutableSet;
import net.minecraft.block.Block;
import net.minecraft.block.BlockFalling;
-import net.minecraft.block.BlockLiquid;
import net.minecraft.block.state.IBlockState;
import net.minecraft.client.entity.EntityPlayerSP;
import net.minecraft.init.Blocks;
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
index 0a11b2555..f72a0446f 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
@@ -30,7 +30,6 @@ import baritone.utils.BlockStateInterface;
import baritone.utils.pathing.MutableMoveResult;
import com.google.common.collect.ImmutableSet;
import net.minecraft.block.Block;
-import net.minecraft.block.BlockLiquid;
import net.minecraft.block.state.IBlockState;
import net.minecraft.client.entity.EntityPlayerSP;
import net.minecraft.init.Blocks;
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
index bc91ee17f..473b14393 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
@@ -33,7 +33,6 @@ import baritone.utils.BlockStateInterface;
import com.google.common.collect.ImmutableSet;
import net.minecraft.block.*;
import net.minecraft.block.state.IBlockState;
-import net.minecraft.enchantment.EnchantmentHelper;
import net.minecraft.init.Blocks;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.Vec3d;
From 41968546d1efb9559b172e4a1d0f66f64bd4c927 Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Fri, 6 Jan 2023 04:09:56 +0100
Subject: [PATCH 48/71] Update workflows
---
.github/workflows/gradle_build.yml | 8 ++++----
.github/workflows/run_tests.yml | 4 ++--
2 files changed, 6 insertions(+), 6 deletions(-)
diff --git a/.github/workflows/gradle_build.yml b/.github/workflows/gradle_build.yml
index 34e93bff2..6a800e98e 100644
--- a/.github/workflows/gradle_build.yml
+++ b/.github/workflows/gradle_build.yml
@@ -13,9 +13,9 @@ jobs:
runs-on: ubuntu-latest
steps:
- - uses: actions/checkout@v2
+ - uses: actions/checkout@v3
- name: Set up JDK 8
- uses: actions/setup-java@v2
+ uses: actions/setup-java@v3
with:
java-version: '8'
distribution: 'adopt'
@@ -27,13 +27,13 @@ jobs:
run: ./gradlew build
- name: Archive Artifacts
- uses: actions/upload-artifact@v2
+ uses: actions/upload-artifact@v3
with:
name: Artifacts
path: dist/
- name: Archive mapping.txt
- uses: actions/upload-artifact@v2
+ uses: actions/upload-artifact@v3
with:
name: Mappings
path: build/tmp/proguard/mapping.txt
diff --git a/.github/workflows/run_tests.yml b/.github/workflows/run_tests.yml
index 1af26a476..08fd28ef6 100644
--- a/.github/workflows/run_tests.yml
+++ b/.github/workflows/run_tests.yml
@@ -11,9 +11,9 @@ jobs:
runs-on: ubuntu-latest
steps:
- - uses: actions/checkout@v2
+ - uses: actions/checkout@v3
- name: Set up JDK 9
- uses: actions/setup-java@v2
+ uses: actions/setup-java@v3
with:
java-version: '8'
distribution: 'adopt'
From 678f8bc77fa5a3f22b364faf29401c62a2e1500c Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Fri, 6 Jan 2023 04:25:03 +0100
Subject: [PATCH 49/71] Use Temurin JDK
---
.github/workflows/gradle_build.yml | 2 +-
.github/workflows/run_tests.yml | 2 +-
2 files changed, 2 insertions(+), 2 deletions(-)
diff --git a/.github/workflows/gradle_build.yml b/.github/workflows/gradle_build.yml
index 6a800e98e..d69498bc3 100644
--- a/.github/workflows/gradle_build.yml
+++ b/.github/workflows/gradle_build.yml
@@ -18,7 +18,7 @@ jobs:
uses: actions/setup-java@v3
with:
java-version: '8'
- distribution: 'adopt'
+ distribution: 'temurin'
- name: Grant execute permission for gradlew
run: chmod +x gradlew
diff --git a/.github/workflows/run_tests.yml b/.github/workflows/run_tests.yml
index 08fd28ef6..18eac5e2e 100644
--- a/.github/workflows/run_tests.yml
+++ b/.github/workflows/run_tests.yml
@@ -16,7 +16,7 @@ jobs:
uses: actions/setup-java@v3
with:
java-version: '8'
- distribution: 'adopt'
+ distribution: 'temurin'
- name: Grant execute permission for gradlew
run: chmod +x gradlew
From a1a94ec0d154dd519b09443f0cb486aeb9ed15b6 Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Fri, 6 Jan 2023 04:26:03 +0100
Subject: [PATCH 50/71] Fix step name
---
.github/workflows/run_tests.yml | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/.github/workflows/run_tests.yml b/.github/workflows/run_tests.yml
index 18eac5e2e..d2d849fb7 100644
--- a/.github/workflows/run_tests.yml
+++ b/.github/workflows/run_tests.yml
@@ -12,7 +12,7 @@ jobs:
steps:
- uses: actions/checkout@v3
- - name: Set up JDK 9
+ - name: Set up JDK 8
uses: actions/setup-java@v3
with:
java-version: '8'
From b0fb474e1dd597fcb65e90c63b65d4e4a0105636 Mon Sep 17 00:00:00 2001
From: Entropy5 <44469915+Entropy5@users.noreply.github.com>
Date: Mon, 9 Jan 2023 02:33:10 +0100
Subject: [PATCH 51/71] buildinlayers ~ buildonlyselection lag fix for big
schematics (skips layers more properly)
---
.../java/baritone/process/BuilderProcess.java | 30 +++++++++++++++++++
1 file changed, 30 insertions(+)
diff --git a/src/main/java/baritone/process/BuilderProcess.java b/src/main/java/baritone/process/BuilderProcess.java
index ccadd5512..9b932a657 100644
--- a/src/main/java/baritone/process/BuilderProcess.java
+++ b/src/main/java/baritone/process/BuilderProcess.java
@@ -67,6 +67,7 @@ import java.io.IOException;
import java.nio.file.Files;
import java.util.*;
import java.util.stream.Collectors;
+import java.util.stream.Stream;
import static baritone.api.pathing.movement.ActionCosts.COST_INF;
@@ -83,6 +84,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
private int layer;
private int numRepeats;
private List approxPlaceable;
+ public final int[] selectionYBounds = {0, 0};
public BuilderProcess(Baritone baritone) {
super(baritone);
@@ -111,6 +113,24 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
this.origin = new Vec3i(x, y, z);
this.paused = false;
this.layer = Baritone.settings().startAtLayer.value;
+ if (Baritone.settings().buildOnlySelection.value) {
+ if (baritone.getSelectionManager().getSelections().length == 0) {
+ logDirect("Poor little kitten forgot to set a selection while BuildOnlySelection is true");
+ }
+ if (Baritone.settings().buildInLayers.value) {
+ OptionalInt minim = Stream.of(baritone.getSelectionManager().getSelections()).mapToInt(sel -> sel.min().y).min();
+ OptionalInt maxim = Stream.of(baritone.getSelectionManager().getSelections()).mapToInt(sel -> sel.max().y).max();
+ logDirect(String.format("Schematic starts at y=%s with height %s", y, schematic.heightY()));
+ logDirect(String.format("Selection starts at y=%s and ends at y=%s", minim.isPresent() ? minim.getAsInt() : 0, maxim.isPresent() ? maxim.getAsInt() : 0));
+ if (minim.isPresent() && maxim.isPresent()) {
+ selectionYBounds[0] = Baritone.settings().layerOrder.value ? y + schematic.heightY() - maxim.getAsInt() : minim.getAsInt() - y;
+ selectionYBounds[1] = Baritone.settings().layerOrder.value ? y + schematic.heightY() - minim.getAsInt() : maxim.getAsInt() - y;
+ }
+ this.layer = this.selectionYBounds[0] / Baritone.settings().layerHeight.value;
+ logDirect("Skipped everything under layer " + this.layer);
+ }
+ }
+
this.numRepeats = 0;
this.observedCompleted = new LongOpenHashSet();
this.incorrectPositions = null;
@@ -459,6 +479,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
}
BuilderCalculationContext bcc = new BuilderCalculationContext();
if (!recalc(bcc)) {
+ checkAboveSelection();
if (Baritone.settings().buildInLayers.value && layer * Baritone.settings().layerHeight.value < realSchematic.heightY()) {
logDirect("Starting layer " + layer);
layer++;
@@ -549,6 +570,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
if (goal == null) {
goal = assemble(bcc, approxPlaceable, true); // we're far away, so assume that we have our whole inventory to recalculate placeable properly
if (goal == null) {
+ checkAboveSelection();
if (Baritone.settings().skipFailedLayers.value && Baritone.settings().buildInLayers.value && layer * Baritone.settings().layerHeight.value < realSchematic.heightY()) {
logDirect("Skipping layer that I cannot construct! Layer #" + layer);
layer++;
@@ -562,6 +584,14 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
return new PathingCommandContext(goal, PathingCommandType.FORCE_REVALIDATE_GOAL_AND_PATH, bcc);
}
+ private void checkAboveSelection() {
+ if (Baritone.settings().buildInLayers.value && Baritone.settings().buildOnlySelection.value &&
+ this.layer * Baritone.settings().layerHeight.value > this.selectionYBounds[1]) {
+ logDirect("Skipped everything above layer " + this.layer);
+ this.layer = realSchematic.heightY() / Baritone.settings().layerHeight.value;
+ }
+ }
+
private boolean recalc(BuilderCalculationContext bcc) {
if (incorrectPositions == null) {
incorrectPositions = new HashSet<>();
From 9a9b4a1874241cfd02d396830196bc4df5e80230 Mon Sep 17 00:00:00 2001
From: Entropy5 <44469915+Entropy5@users.noreply.github.com>
Date: Tue, 10 Jan 2023 05:56:30 +0100
Subject: [PATCH 52/71] bugfix for odd height schematics
---
src/main/java/baritone/process/BuilderProcess.java | 12 ++++++------
1 file changed, 6 insertions(+), 6 deletions(-)
diff --git a/src/main/java/baritone/process/BuilderProcess.java b/src/main/java/baritone/process/BuilderProcess.java
index 9b932a657..d8b5316ac 100644
--- a/src/main/java/baritone/process/BuilderProcess.java
+++ b/src/main/java/baritone/process/BuilderProcess.java
@@ -84,7 +84,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
private int layer;
private int numRepeats;
private List approxPlaceable;
- public final int[] selectionYBounds = {0, 0};
+ public final int[] selectionLayerBounds = {0, 0};
public BuilderProcess(Baritone baritone) {
super(baritone);
@@ -123,10 +123,10 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
logDirect(String.format("Schematic starts at y=%s with height %s", y, schematic.heightY()));
logDirect(String.format("Selection starts at y=%s and ends at y=%s", minim.isPresent() ? minim.getAsInt() : 0, maxim.isPresent() ? maxim.getAsInt() : 0));
if (minim.isPresent() && maxim.isPresent()) {
- selectionYBounds[0] = Baritone.settings().layerOrder.value ? y + schematic.heightY() - maxim.getAsInt() : minim.getAsInt() - y;
- selectionYBounds[1] = Baritone.settings().layerOrder.value ? y + schematic.heightY() - minim.getAsInt() : maxim.getAsInt() - y;
+ selectionLayerBounds[0] = Baritone.settings().layerOrder.value ? y + schematic.heightY() - maxim.getAsInt() : minim.getAsInt() - y;
+ selectionLayerBounds[1] = Baritone.settings().layerOrder.value ? y + schematic.heightY() - minim.getAsInt() : maxim.getAsInt() - y;
}
- this.layer = this.selectionYBounds[0] / Baritone.settings().layerHeight.value;
+ this.layer = this.selectionLayerBounds[0] / Baritone.settings().layerHeight.value;
logDirect("Skipped everything under layer " + this.layer);
}
}
@@ -586,9 +586,9 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
private void checkAboveSelection() {
if (Baritone.settings().buildInLayers.value && Baritone.settings().buildOnlySelection.value &&
- this.layer * Baritone.settings().layerHeight.value > this.selectionYBounds[1]) {
+ this.layer * Baritone.settings().layerHeight.value > this.selectionLayerBounds[1]) {
logDirect("Skipped everything above layer " + this.layer);
- this.layer = realSchematic.heightY() / Baritone.settings().layerHeight.value;
+ this.layer = realSchematic.heightY() / Baritone.settings().layerHeight.value + 1;
}
}
From 1680eeb80da785338a2d27e4c432610be5e102f2 Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Tue, 10 Jan 2023 17:25:32 +0100
Subject: [PATCH 53/71] Handle mods breaking our world loading hook
---
.../java/baritone/cache/WorldProvider.java | 18 ++++++++++++++++++
1 file changed, 18 insertions(+)
diff --git a/src/main/java/baritone/cache/WorldProvider.java b/src/main/java/baritone/cache/WorldProvider.java
index a7756137c..03ada444f 100644
--- a/src/main/java/baritone/cache/WorldProvider.java
+++ b/src/main/java/baritone/cache/WorldProvider.java
@@ -24,6 +24,7 @@ import baritone.utils.accessor.IAnvilChunkLoader;
import baritone.utils.accessor.IChunkProviderServer;
import net.minecraft.server.integrated.IntegratedServer;
import net.minecraft.world.WorldServer;
+import net.minecraft.world.World;
import org.apache.commons.lang3.SystemUtils;
import java.io.File;
@@ -44,9 +45,11 @@ public class WorldProvider implements IWorldProvider, Helper {
private static final Map worldCache = new HashMap<>(); // this is how the bots have the same cached world
private WorldData currentWorld;
+ private World mcWorld; // this let's us detect a broken load/unload hook
@Override
public final WorldData getCurrentWorld() {
+ detectAndHandleBrokenLoading();
return this.currentWorld;
}
@@ -83,6 +86,7 @@ public class WorldProvider implements IWorldProvider, Helper {
} else {
//replaymod causes null currentServerData and false singleplayer.
currentWorld = null;
+ mcWorld = mc.world;
return;
}
if (SystemUtils.IS_OS_WINDOWS) {
@@ -110,11 +114,13 @@ public class WorldProvider implements IWorldProvider, Helper {
synchronized (worldCache) {
this.currentWorld = worldCache.computeIfAbsent(dir, d -> new WorldData(d, dimension));
}
+ this.mcWorld = mc.world;
}
public final void closeWorld() {
WorldData world = this.currentWorld;
this.currentWorld = null;
+ this.mcWorld = null;
if (world == null) {
return;
}
@@ -122,8 +128,20 @@ public class WorldProvider implements IWorldProvider, Helper {
}
public final void ifWorldLoaded(Consumer currentWorldConsumer) {
+ detectAndHandleBrokenLoading();
if (this.currentWorld != null) {
currentWorldConsumer.accept(this.currentWorld);
}
}
+
+ private final void detectAndHandleBrokenLoading() {
+ if (this.mcWorld != mc.world) {
+ if (this.currentWorld != null) {
+ closeWorld();
+ }
+ if (mc.world != null) {
+ initWorld(mc.world.provider.getDimensionType().getId());
+ }
+ }
+ }
}
From 77b2b26a7a86bfd7a3a3d05fd7055f81349f2a05 Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Tue, 10 Jan 2023 18:52:18 +0100
Subject: [PATCH 54/71] Add fix for 1.19.3 here already
---
src/main/java/baritone/cache/WorldProvider.java | 2 ++
1 file changed, 2 insertions(+)
diff --git a/src/main/java/baritone/cache/WorldProvider.java b/src/main/java/baritone/cache/WorldProvider.java
index 03ada444f..c335b364b 100644
--- a/src/main/java/baritone/cache/WorldProvider.java
+++ b/src/main/java/baritone/cache/WorldProvider.java
@@ -142,6 +142,8 @@ public class WorldProvider implements IWorldProvider, Helper {
if (mc.world != null) {
initWorld(mc.world.provider.getDimensionType().getId());
}
+ } else if (currentWorld == null && mc.world != null) {
+ initWorld(mc.world.provider.getDimensionType().getId());
}
}
}
From 75e39e7ef553a07cfe0e2f577e8bd1802dc8e1fb Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Tue, 10 Jan 2023 17:30:33 +0100
Subject: [PATCH 55/71] Log when doing things out of the ordinary
---
src/main/java/baritone/cache/WorldProvider.java | 4 ++++
1 file changed, 4 insertions(+)
diff --git a/src/main/java/baritone/cache/WorldProvider.java b/src/main/java/baritone/cache/WorldProvider.java
index c335b364b..3addb1762 100644
--- a/src/main/java/baritone/cache/WorldProvider.java
+++ b/src/main/java/baritone/cache/WorldProvider.java
@@ -85,6 +85,7 @@ public class WorldProvider implements IWorldProvider, Helper {
folderName = mc.getCurrentServerData().serverIP;
} else {
//replaymod causes null currentServerData and false singleplayer.
+ System.out.println("World seems to be a replay. Not loading Baritone cache.");
currentWorld = null;
mcWorld = mc.world;
return;
@@ -137,12 +138,15 @@ public class WorldProvider implements IWorldProvider, Helper {
private final void detectAndHandleBrokenLoading() {
if (this.mcWorld != mc.world) {
if (this.currentWorld != null) {
+ System.out.println("mc.world unloaded unnoticed! Unloading Baritone cache now.");
closeWorld();
}
if (mc.world != null) {
+ System.out.println("mc.world loaded unnoticed! Loading Baritone cache now.");
initWorld(mc.world.provider.getDimensionType().getId());
}
} else if (currentWorld == null && mc.world != null) {
+ System.out.println("Retrying to load Baritone cache");
initWorld(mc.world.provider.getDimensionType().getId());
}
}
From a6f3c956846a357fbf3cafd1e6f5bf44bc158e2c Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Tue, 10 Jan 2023 18:53:43 +0100
Subject: [PATCH 56/71] Don't spam the log when in a replay
---
src/main/java/baritone/cache/WorldProvider.java | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/main/java/baritone/cache/WorldProvider.java b/src/main/java/baritone/cache/WorldProvider.java
index 3addb1762..98ec1bbb2 100644
--- a/src/main/java/baritone/cache/WorldProvider.java
+++ b/src/main/java/baritone/cache/WorldProvider.java
@@ -145,7 +145,7 @@ public class WorldProvider implements IWorldProvider, Helper {
System.out.println("mc.world loaded unnoticed! Loading Baritone cache now.");
initWorld(mc.world.provider.getDimensionType().getId());
}
- } else if (currentWorld == null && mc.world != null) {
+ } else if (currentWorld == null && mc.world != null && (mc.isSingleplayer() || mc.getCurrentServerData() != null)) {
System.out.println("Retrying to load Baritone cache");
initWorld(mc.world.provider.getDimensionType().getId());
}
From 98a87d099b0d0d4f147fa7d35f674c08de5c2379 Mon Sep 17 00:00:00 2001
From: Entropy5 <44469915+Entropy5@users.noreply.github.com>
Date: Wed, 11 Jan 2023 04:36:15 +0100
Subject: [PATCH 57/71] zac suggestion
---
.../java/baritone/process/BuilderProcess.java | 33 ++++++++-----------
1 file changed, 13 insertions(+), 20 deletions(-)
diff --git a/src/main/java/baritone/process/BuilderProcess.java b/src/main/java/baritone/process/BuilderProcess.java
index d8b5316ac..298c88770 100644
--- a/src/main/java/baritone/process/BuilderProcess.java
+++ b/src/main/java/baritone/process/BuilderProcess.java
@@ -84,7 +84,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
private int layer;
private int numRepeats;
private List approxPlaceable;
- public final int[] selectionLayerBounds = {0, 0};
+ public int stopAtHeight = 0;
public BuilderProcess(Baritone baritone) {
super(baritone);
@@ -113,21 +113,24 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
this.origin = new Vec3i(x, y, z);
this.paused = false;
this.layer = Baritone.settings().startAtLayer.value;
+ this.stopAtHeight = schematic.heightY();
if (Baritone.settings().buildOnlySelection.value) {
if (baritone.getSelectionManager().getSelections().length == 0) {
logDirect("Poor little kitten forgot to set a selection while BuildOnlySelection is true");
- }
- if (Baritone.settings().buildInLayers.value) {
+ this.stopAtHeight = 0;
+ } else if (Baritone.settings().buildInLayers.value) {
OptionalInt minim = Stream.of(baritone.getSelectionManager().getSelections()).mapToInt(sel -> sel.min().y).min();
OptionalInt maxim = Stream.of(baritone.getSelectionManager().getSelections()).mapToInt(sel -> sel.max().y).max();
- logDirect(String.format("Schematic starts at y=%s with height %s", y, schematic.heightY()));
- logDirect(String.format("Selection starts at y=%s and ends at y=%s", minim.isPresent() ? minim.getAsInt() : 0, maxim.isPresent() ? maxim.getAsInt() : 0));
if (minim.isPresent() && maxim.isPresent()) {
- selectionLayerBounds[0] = Baritone.settings().layerOrder.value ? y + schematic.heightY() - maxim.getAsInt() : minim.getAsInt() - y;
- selectionLayerBounds[1] = Baritone.settings().layerOrder.value ? y + schematic.heightY() - minim.getAsInt() : maxim.getAsInt() - y;
+ int startAtHeight = Baritone.settings().layerOrder.value ? y + schematic.heightY() - maxim.getAsInt() : minim.getAsInt() - y;
+ this.stopAtHeight = (Baritone.settings().layerOrder.value ? y + schematic.heightY() - minim.getAsInt() : maxim.getAsInt() - y) + 1;
+ this.layer = startAtHeight / Baritone.settings().layerHeight.value;
+ if (Baritone.settings().chatDebug.value) {
+ logDirect(String.format("Schematic starts at y=%s with height %s", y, schematic.heightY()));
+ logDirect(String.format("Selection starts at y=%s and ends at y=%s", minim.getAsInt(), maxim.getAsInt()));
+ logDirect(String.format("Considering relevant height %s - %s", startAtHeight, this.stopAtHeight));
+ }
}
- this.layer = this.selectionLayerBounds[0] / Baritone.settings().layerHeight.value;
- logDirect("Skipped everything under layer " + this.layer);
}
}
@@ -479,8 +482,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
}
BuilderCalculationContext bcc = new BuilderCalculationContext();
if (!recalc(bcc)) {
- checkAboveSelection();
- if (Baritone.settings().buildInLayers.value && layer * Baritone.settings().layerHeight.value < realSchematic.heightY()) {
+ if (Baritone.settings().buildInLayers.value && layer * Baritone.settings().layerHeight.value < stopAtHeight) {
logDirect("Starting layer " + layer);
layer++;
return onTick(calcFailed, isSafeToCancel, recursions + 1);
@@ -570,7 +572,6 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
if (goal == null) {
goal = assemble(bcc, approxPlaceable, true); // we're far away, so assume that we have our whole inventory to recalculate placeable properly
if (goal == null) {
- checkAboveSelection();
if (Baritone.settings().skipFailedLayers.value && Baritone.settings().buildInLayers.value && layer * Baritone.settings().layerHeight.value < realSchematic.heightY()) {
logDirect("Skipping layer that I cannot construct! Layer #" + layer);
layer++;
@@ -584,14 +585,6 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
return new PathingCommandContext(goal, PathingCommandType.FORCE_REVALIDATE_GOAL_AND_PATH, bcc);
}
- private void checkAboveSelection() {
- if (Baritone.settings().buildInLayers.value && Baritone.settings().buildOnlySelection.value &&
- this.layer * Baritone.settings().layerHeight.value > this.selectionLayerBounds[1]) {
- logDirect("Skipped everything above layer " + this.layer);
- this.layer = realSchematic.heightY() / Baritone.settings().layerHeight.value + 1;
- }
- }
-
private boolean recalc(BuilderCalculationContext bcc) {
if (incorrectPositions == null) {
incorrectPositions = new HashSet<>();
From de5f6d5fced796fa6af88092e6202f5e18289562 Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Wed, 11 Jan 2023 23:56:52 +0100
Subject: [PATCH 58/71] Apply suggested reordering
---
.../movement/movements/MovementDiagonal.java | 11 ++++++-----
.../movement/movements/MovementPillar.java | 2 +-
.../movement/movements/MovementTraverse.java | 17 +++++++++--------
3 files changed, 16 insertions(+), 14 deletions(-)
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
index f72a0446f..9a17d22bc 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
@@ -114,6 +114,7 @@ public class MovementDiagonal extends Movement {
return;
}
IBlockState destInto = context.get(destX, y, destZ);
+ IBlockState fromDown = context.get(x, y - 1, z);
boolean ascend = false;
IBlockState destWalkOn;
boolean descend = false;
@@ -126,9 +127,9 @@ public class MovementDiagonal extends Movement {
destWalkOn = destInto;
} else {
destWalkOn = context.get(destX, y - 1, destZ);
- boolean standingOnABlock = MovementHelper.mustBeSolidToWalkOn(context, x, y-1, z, context.get(x, y-1, z));
+ boolean standingOnABlock = MovementHelper.mustBeSolidToWalkOn(context, x, y - 1, z, fromDown);
frostWalker = standingOnABlock && MovementHelper.canUseFrostWalker(context, destWalkOn);
- if (!MovementHelper.canWalkOn(context, destX, y - 1, destZ, destWalkOn) && !frostWalker) {
+ if (!frostWalker && !MovementHelper.canWalkOn(context, destX, y - 1, destZ, destWalkOn)) {
descend = true;
if (!context.allowDiagonalDescend || !MovementHelper.canWalkOn(context, destX, y - 2, destZ) || !MovementHelper.canWalkThrough(context, destX, y - 1, destZ, destWalkOn)) {
return;
@@ -145,11 +146,11 @@ public class MovementDiagonal extends Movement {
} else if (destWalkOn.getBlock() == Blocks.WATER) {
multiplier += context.walkOnWaterOnePenalty * SQRT_2;
}
- Block fromDown = context.get(x, y - 1, z).getBlock();
- if (fromDown == Blocks.LADDER || fromDown == Blocks.VINE) {
+ Block fromDownBlock = fromDown.getBlock();
+ if (fromDownBlock == Blocks.LADDER || fromDownBlock == Blocks.VINE) {
return;
}
- if (fromDown == Blocks.SOUL_SAND) {
+ if (fromDownBlock == Blocks.SOUL_SAND) {
multiplier += (WALK_ONE_OVER_SOUL_SAND_COST - WALK_ONE_BLOCK_COST) / 2;
}
Block cuttingOver1 = context.get(x, y - 1, destZ).getBlock();
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementPillar.java b/src/main/java/baritone/pathing/movement/movements/MovementPillar.java
index 5d8d32a8c..cfa9d9260 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementPillar.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementPillar.java
@@ -101,7 +101,7 @@ public class MovementPillar extends Movement {
// if we're standing on water and assumeWalkOnWater is false, we must have ascended to here, or sneak backplaced, so it is possible to pillar again
return COST_INF;
}
- if (fromDown.getBlock() instanceof BlockLiquid && (from == Blocks.WATERLILY || from == Blocks.CARPET)) {
+ if ((from == Blocks.WATERLILY || from == Blocks.CARPET) && fromDown.getBlock() instanceof BlockLiquid) {
// to ascend here we'd have to break the block we are standing on
return COST_INF;
}
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
index 473b14393..c8a3528ee 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
@@ -71,10 +71,11 @@ public class MovementTraverse extends Movement {
IBlockState pb0 = context.get(destX, y + 1, destZ);
IBlockState pb1 = context.get(destX, y, destZ);
IBlockState destOn = context.get(destX, y - 1, destZ);
- Block srcDown = context.getBlock(x, y - 1, z);
- boolean standingOnABlock = MovementHelper.mustBeSolidToWalkOn(context, x, y-1, z, context.get(x, y-1, z));
+ IBlockState srcDown = context.get(x, y - 1, z);
+ Block srcDownBlock = srcDown.getBlock();
+ boolean standingOnABlock = MovementHelper.mustBeSolidToWalkOn(context, x, y-1, z, srcDown);
boolean frostWalker = standingOnABlock && !context.assumeWalkOnWater && MovementHelper.canUseFrostWalker(context, destOn);
- if (MovementHelper.canWalkOn(context, destX, y - 1, destZ, destOn) || frostWalker) { //this is a walk, not a bridge
+ if (frostWalker || MovementHelper.canWalkOn(context, destX, y - 1, destZ, destOn)) { //this is a walk, not a bridge
double WC = WALK_ONE_BLOCK_COST;
boolean water = false;
if (MovementHelper.isWater(pb0.getBlock()) || MovementHelper.isWater(pb1.getBlock())) {
@@ -88,7 +89,7 @@ public class MovementTraverse extends Movement {
} else if (destOn.getBlock() == Blocks.WATER) {
WC += context.walkOnWaterOnePenalty;
}
- if (srcDown == Blocks.SOUL_SAND) {
+ if (srcDownBlock == Blocks.SOUL_SAND) {
WC += (WALK_ONE_OVER_SOUL_SAND_COST - WALK_ONE_BLOCK_COST) / 2;
}
}
@@ -106,13 +107,13 @@ public class MovementTraverse extends Movement {
}
return WC;
}
- if (srcDown == Blocks.LADDER || srcDown == Blocks.VINE) {
+ if (srcDownBlock == Blocks.LADDER || srcDownBlock == Blocks.VINE) {
hardness1 *= 5;
hardness2 *= 5;
}
return WC + hardness1 + hardness2;
} else {//this is a bridge, so we need to place a block
- if (srcDown == Blocks.LADDER || srcDown == Blocks.VINE) {
+ if (srcDownBlock == Blocks.LADDER || srcDownBlock == Blocks.VINE) {
return COST_INF;
}
if (MovementHelper.isReplaceable(destX, y - 1, destZ, destOn, context.bsi)) {
@@ -143,14 +144,14 @@ public class MovementTraverse extends Movement {
}
}
// now that we've checked all possible directions to side place, we actually need to backplace
- if (srcDown == Blocks.SOUL_SAND || (srcDown instanceof BlockSlab && !((BlockSlab) srcDown).isDouble())) {
+ if (srcDownBlock == Blocks.SOUL_SAND || (srcDownBlock instanceof BlockSlab && !((BlockSlab) srcDownBlock).isDouble())) {
return COST_INF; // can't sneak and backplace against soul sand or half slabs (regardless of whether it's top half or bottom half) =/
}
if (!standingOnABlock) { // standing on water / swimming
return COST_INF; // this is obviously impossible
}
Block blockSrc = context.getBlock(x, y, z);
- if (srcDown instanceof BlockLiquid && (blockSrc == Blocks.WATERLILY || blockSrc == Blocks.CARPET)) {
+ if ((blockSrc == Blocks.WATERLILY || blockSrc == Blocks.CARPET) && srcDownBlock instanceof BlockLiquid) {
return COST_INF; // we can stand on these but can't place against them
}
WC = WC * (SNEAK_ONE_BLOCK_COST / WALK_ONE_BLOCK_COST);//since we are sneak backplacing, we are sneaking lol
From 16a62625b35d42420ea26e2cfb1c1ea2f6939c17 Mon Sep 17 00:00:00 2001
From: Entropy5 <44469915+Entropy5@users.noreply.github.com>
Date: Thu, 12 Jan 2023 04:29:31 +0100
Subject: [PATCH 59/71] this seems to work as well?
---
src/main/java/baritone/process/BuilderProcess.java | 13 ++++++-------
1 file changed, 6 insertions(+), 7 deletions(-)
diff --git a/src/main/java/baritone/process/BuilderProcess.java b/src/main/java/baritone/process/BuilderProcess.java
index 298c88770..f3f138c96 100644
--- a/src/main/java/baritone/process/BuilderProcess.java
+++ b/src/main/java/baritone/process/BuilderProcess.java
@@ -95,6 +95,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
this.name = name;
this.schematic = schematic;
this.realSchematic = null;
+ boolean buildingSelectionSchematic = schematic instanceof SelectionSchematic;
if (!Baritone.settings().buildSubstitutes.value.isEmpty()) {
this.schematic = new SubstituteSchematic(this.schematic, Baritone.settings().buildSubstitutes.value);
}
@@ -114,7 +115,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
this.paused = false;
this.layer = Baritone.settings().startAtLayer.value;
this.stopAtHeight = schematic.heightY();
- if (Baritone.settings().buildOnlySelection.value) {
+ if (Baritone.settings().buildOnlySelection.value && buildingSelectionSchematic) { // currently redundant but safer maybe
if (baritone.getSelectionManager().getSelections().length == 0) {
logDirect("Poor little kitten forgot to set a selection while BuildOnlySelection is true");
this.stopAtHeight = 0;
@@ -124,12 +125,10 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
if (minim.isPresent() && maxim.isPresent()) {
int startAtHeight = Baritone.settings().layerOrder.value ? y + schematic.heightY() - maxim.getAsInt() : minim.getAsInt() - y;
this.stopAtHeight = (Baritone.settings().layerOrder.value ? y + schematic.heightY() - minim.getAsInt() : maxim.getAsInt() - y) + 1;
- this.layer = startAtHeight / Baritone.settings().layerHeight.value;
- if (Baritone.settings().chatDebug.value) {
- logDirect(String.format("Schematic starts at y=%s with height %s", y, schematic.heightY()));
- logDirect(String.format("Selection starts at y=%s and ends at y=%s", minim.getAsInt(), maxim.getAsInt()));
- logDirect(String.format("Considering relevant height %s - %s", startAtHeight, this.stopAtHeight));
- }
+ this.layer = Math.max(this.layer, startAtHeight / Baritone.settings().layerHeight.value); // startAtLayer or startAtHeight, whichever is highest
+ logDebug(String.format("Schematic starts at y=%s with height %s", y, schematic.heightY()));
+ logDebug(String.format("Selection starts at y=%s and ends at y=%s", minim.getAsInt(), maxim.getAsInt()));
+ logDebug(String.format("Considering relevant height %s - %s", startAtHeight, this.stopAtHeight));
}
}
}
From c8dd4f26f7496499ffbd94c7ccf01e50eb1a227d Mon Sep 17 00:00:00 2001
From: Argentoz <35398135+Argentoz@users.noreply.github.com>
Date: Thu, 12 Jan 2023 15:02:54 +0300
Subject: [PATCH 60/71] Fix :)
WTF
---
src/main/java/baritone/pathing/movement/MovementHelper.java | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index e3fc6a038..44cd1f6ac 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -51,7 +51,7 @@ import static baritone.pathing.precompute.Ternary.*;
public interface MovementHelper extends ActionCosts, Helper {
static boolean avoidBreaking(BlockStateInterface bsi, int x, int y, int z, IBlockState state) {
- if (!bsi.worldBorder.canPlaceAt(x, y)) {
+ if (!bsi.worldBorder.canPlaceAt(x, z)) {
return true;
}
Block b = state.getBlock();
From c39b6c3fe7bf297e63377729d5c18807255650dd Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Thu, 12 Jan 2023 21:39:55 +0100
Subject: [PATCH 61/71] Don't grab state if we don't need it
---
.../baritone/pathing/movement/movements/MovementDiagonal.java | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
index 9a17d22bc..f56babc2d 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
@@ -114,7 +114,7 @@ public class MovementDiagonal extends Movement {
return;
}
IBlockState destInto = context.get(destX, y, destZ);
- IBlockState fromDown = context.get(x, y - 1, z);
+ IBlockState fromDown;
boolean ascend = false;
IBlockState destWalkOn;
boolean descend = false;
@@ -125,8 +125,10 @@ public class MovementDiagonal extends Movement {
return;
}
destWalkOn = destInto;
+ fromDown = context.get(x, y - 1, z);
} else {
destWalkOn = context.get(destX, y - 1, destZ);
+ fromDown = context.get(x, y - 1, z);
boolean standingOnABlock = MovementHelper.mustBeSolidToWalkOn(context, x, y - 1, z, fromDown);
frostWalker = standingOnABlock && MovementHelper.canUseFrostWalker(context, destWalkOn);
if (!frostWalker && !MovementHelper.canWalkOn(context, destX, y - 1, destZ, destWalkOn)) {
From 9935da8a6f623d881af8b4bdf40666990701ff8d Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Thu, 12 Jan 2023 21:57:54 +0100
Subject: [PATCH 62/71] Add explanation and add extra check
---
src/main/java/baritone/pathing/path/PathExecutor.java | 7 ++++++-
1 file changed, 6 insertions(+), 1 deletion(-)
diff --git a/src/main/java/baritone/pathing/path/PathExecutor.java b/src/main/java/baritone/pathing/path/PathExecutor.java
index 387548517..e68de4805 100644
--- a/src/main/java/baritone/pathing/path/PathExecutor.java
+++ b/src/main/java/baritone/pathing/path/PathExecutor.java
@@ -388,7 +388,12 @@ public class PathExecutor implements IPathExecutor, Helper {
// Since MovementDescend can't know the next movement we have to tell it
if (next instanceof MovementTraverse || next instanceof MovementParkour) {
boolean couldPlaceInstead = Baritone.settings().allowPlace.value && behavior.baritone.getInventoryBehavior().hasGenericThrowaway() && next instanceof MovementParkour; // traverse doesn't react fast enough
- boolean sameFlatDirection = current.getDirection().up().crossProduct(next.getDirection()).equals(BlockPos.ORIGIN); // here's why you learn maths in school
+ // this is true if the next movement does not ascend or descends and goes into the same cardinal direction (N-NE-E-SE-S-SW-W-NW) as the descend
+ // in that case current.getDirection() is e.g. (0, -1, 1) and next.getDirection() is e.g. (0, 0, 3) so the cross product of (0, 0, 1) and (0, 0, 3) is taken, which is (0, 0, 0) because the vectors are colinear (don't form a plane)
+ // since movements in exactly the opposite direction (e.g. descend (0, -1, 1) and traverse (0, 0, -1)) would also pass this check we also have to rule out that case
+ // we can do that by adding the directions because traverse is always 1 long like descend and parkour can't jump through current.getSrc().down()
+ boolean sameFlatDirection = !current.getDirection().up().add(next.getDirection()).equals(BlockPos.ORIGIN)
+ && current.getDirection().up().crossProduct(next.getDirection()).equals(BlockPos.ORIGIN); // here's why you learn maths in school
if (sameFlatDirection && !couldPlaceInstead) {
((MovementDescend) current).forceSafeMode();
}
From 85c21fa8e35d0ca8cbb4d58cc463f4db0eae565e Mon Sep 17 00:00:00 2001
From: leijurv
Date: Thu, 12 Jan 2023 14:52:38 -0800
Subject: [PATCH 63/71] add comment
---
.../baritone/pathing/movement/movements/MovementParkour.java | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementParkour.java b/src/main/java/baritone/pathing/movement/movements/MovementParkour.java
index 76b17f0f6..a36f84bce 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementParkour.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementParkour.java
@@ -276,7 +276,7 @@ public class MovementParkour extends Movement {
}
} else if (!ctx.playerFeet().equals(src)) {
if (ctx.playerFeet().equals(src.offset(direction)) || ctx.player().posY - src.y > 0.0001) {
- if (Baritone.settings().allowPlace.value
+ if (Baritone.settings().allowPlace.value // see PR #3775
&& ((Baritone) baritone).getInventoryBehavior().hasGenericThrowaway()
&& !MovementHelper.canWalkOn(ctx, dest.down())
&& !ctx.player().onGround
From 6a175379fb84d5fea09dc0ec3489967eb7d570e6 Mon Sep 17 00:00:00 2001
From: Leijurv
Date: Fri, 13 Jan 2023 11:10:24 -0800
Subject: [PATCH 64/71] v1.2.16
---
build.gradle | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/build.gradle b/build.gradle
index b922fc900..67c303265 100755
--- a/build.gradle
+++ b/build.gradle
@@ -16,7 +16,7 @@
*/
group 'baritone'
-version '1.2.15'
+version '1.2.16'
buildscript {
repositories {
From 6bbdba7a2182dcfe13ed12cc78a36c2afbc79d64 Mon Sep 17 00:00:00 2001
From: Leijurv
Date: Fri, 13 Jan 2023 11:17:57 -0800
Subject: [PATCH 65/71] bump
---
README.md | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
diff --git a/README.md b/README.md
index c50caf56a..1b5c70935 100644
--- a/README.md
+++ b/README.md
@@ -54,7 +54,9 @@ Baritone is the pathfinding system used in [Impact](https://impactclient.net/) s
[Tutorial playlist](https://www.youtube.com/playlist?list=PLnwnJ1qsS7CoQl9Si-RTluuzCo_4Oulpa)
-The easiest way to install Baritone is to install [Impact](https://impactclient.net/), which comes with Baritone. The second easiest way (for 1.12.2 only) is to install the v1.2.* `api-forge` jar from [releases](https://github.com/cabaletta/baritone/releases). **For 1.12.2 Forge, just click [here](https://github.com/cabaletta/baritone/releases/download/v1.2.15/baritone-api-forge-1.2.15.jar)**. Otherwise, see [Installation & setup](SETUP.md). Once Baritone is installed, look [here](USAGE.md) for instructions on how to use it.
+The easiest way to install Baritone is to install [Impact](https://impactclient.net/), which comes with Baritone. The second easiest way (for 1.12.2 only) is to
+install the v1.2.* `api-forge` jar from [releases](https://github.com/cabaletta/baritone/releases). **For 1.12.2 Forge, just click
+[here](https://github.com/cabaletta/baritone/releases/download/v1.2.16/baritone-api-forge-1.2.16.jar)**. Otherwise, see [Installation & setup](SETUP.md). Once Baritone is installed, look [here](USAGE.md) for instructions on how to use it.
For 1.16.5, [click here](https://www.youtube.com/watch?v=_4eVJ9Qz2J8) and see description. If you need Forge or Fabric 1.16.5, look [here](https://github.com/cabaletta/baritone/releases/tag/v1.6.3) and get the `api-forge` or `api-fabric` jar. **For 1.16.5 Fabric, just click [here](https://github.com/cabaletta/baritone/releases/download/v1.6.3/baritone-api-fabric-1.6.3.jar)**.
From a3f70e7977128641ded8cb3635ddf47ca5d20d64 Mon Sep 17 00:00:00 2001
From: Leijurv
Date: Sun, 15 Jan 2023 00:56:30 -0800
Subject: [PATCH 66/71] add fullypassable to precomputeddata
---
.../pathing/movement/MovementHelper.java | 73 +++++++++++--------
.../movement/movements/MovementParkour.java | 16 ++--
.../pathing/precompute/PrecomputedData.java | 27 ++++++-
3 files changed, 78 insertions(+), 38 deletions(-)
diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index c32cde601..575815ea2 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -37,7 +37,6 @@ import net.minecraft.util.EnumFacing;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.RayTraceResult;
import net.minecraft.util.math.Vec3d;
-import net.minecraft.world.IBlockAccess;
import java.util.Optional;
@@ -210,33 +209,10 @@ public interface MovementHelper extends ActionCosts, Helper {
return block.isPassable(bsi.access, bsi.isPassableBlockPos.setPos(x, y, z));
}
-
- /**
- * canWalkThrough but also won't impede movement at all. so not including doors or fence gates (we'd have to right click),
- * not including water, and not including ladders or vines or cobwebs (they slow us down)
- *
- * @param context Calculation context to provide block state lookup
- * @param x The block's x position
- * @param y The block's y position
- * @param z The block's z position
- * @return Whether or not the block at the specified position
- */
- static boolean fullyPassable(CalculationContext context, int x, int y, int z) {
- return fullyPassable(
- context.bsi.access,
- context.bsi.isPassableBlockPos.setPos(x, y, z),
- context.bsi.get0(x, y, z)
- );
- }
-
- static boolean fullyPassable(IPlayerContext ctx, BlockPos pos) {
- return fullyPassable(ctx.world(), pos, ctx.world().getBlockState(pos));
- }
-
- static boolean fullyPassable(IBlockAccess access, BlockPos pos, IBlockState state) {
+ static Ternary fullyPassableBlockState(IBlockState state) {
Block block = state.getBlock();
if (block == Blocks.AIR) { // early return for most common case
- return true;
+ return YES;
}
// exceptions - blocks that are isPassable true, but we can't actually jump through
if (block == Blocks.FIRE
@@ -252,10 +228,49 @@ public interface MovementHelper extends ActionCosts, Helper {
|| block instanceof BlockTrapDoor
|| block instanceof BlockEndPortal
|| block instanceof BlockSkull) {
- return false;
+ return NO;
}
// door, fence gate, liquid, trapdoor have been accounted for, nothing else uses the world or pos parameters
- return block.isPassable(access, pos);
+ // at least in 1.12.2 vanilla, that is.....
+ try { // A dodgy catch-all at the end, for most blocks with default behaviour this will work, however where blocks are special this will error out, and we can handle it when we have this information
+ if (block.isPassable(null, null)) {
+ return YES;
+ } else {
+ return NO;
+ }
+ } catch (Throwable exception) {
+ // see PR #1087 for why
+ System.out.println("The block " + state.getBlock().getLocalizedName() + " requires a special case due to the exception " + exception.getMessage());
+ return MAYBE;
+ }
+ }
+
+ /**
+ * canWalkThrough but also won't impede movement at all. so not including doors or fence gates (we'd have to right click),
+ * not including water, and not including ladders or vines or cobwebs (they slow us down)
+ */
+ static boolean fullyPassable(CalculationContext context, int x, int y, int z) {
+ return fullyPassable(context, x, y, z, context.get(x, y, z));
+ }
+
+ static boolean fullyPassable(CalculationContext context, int x, int y, int z, IBlockState state) {
+ return context.precomputedData.fullyPassable(context.bsi, x, y, z, state);
+ }
+
+ static boolean fullyPassable(IPlayerContext ctx, BlockPos pos) {
+ IBlockState state = ctx.world().getBlockState(pos);
+ Ternary fullyPassable = fullyPassableBlockState(state);
+ if (fullyPassable == YES) {
+ return true;
+ }
+ if (fullyPassable == NO) {
+ return false;
+ }
+ return fullyPassablePosition(new BlockStateInterface(ctx), pos.getX(), pos.getY(), pos.getZ(), state); // meh
+ }
+
+ static boolean fullyPassablePosition(BlockStateInterface bsi, int x, int y, int z, IBlockState state) {
+ return state.getBlock().isPassable(bsi.access, bsi.isPassableBlockPos.setPos(x, y, z));
}
static boolean isReplaceable(int x, int y, int z, IBlockState state, BlockStateInterface bsi) {
@@ -488,7 +503,7 @@ public interface MovementHelper extends ActionCosts, Helper {
if (context.assumeWalkOnWater) {
return false;
}
- Block blockAbove = context.getBlock(x, y+1, z);
+ Block blockAbove = context.getBlock(x, y + 1, z);
if (blockAbove instanceof BlockLiquid) {
return false;
}
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementParkour.java b/src/main/java/baritone/pathing/movement/movements/MovementParkour.java
index a36f84bce..9a3925a02 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementParkour.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementParkour.java
@@ -112,13 +112,13 @@ public class MovementParkour extends Movement {
maxJump = 3;
}
}
-
+
// check parkour jumps from smallest to largest for obstacles/walls and landing positions
int verifiedMaxJump = 1; // i - 1 (when i = 2)
for (int i = 2; i <= maxJump; i++) {
int destX = x + xDiff * i;
int destZ = z + zDiff * i;
-
+
// check head/feet
if (!MovementHelper.fullyPassable(context, destX, y + 1, destZ)) {
break;
@@ -126,10 +126,10 @@ public class MovementParkour extends Movement {
if (!MovementHelper.fullyPassable(context, destX, y + 2, destZ)) {
break;
}
-
+
// check for ascend landing position
IBlockState destInto = context.bsi.get0(destX, y, destZ);
- if (!MovementHelper.fullyPassable(context.bsi.access, context.bsi.isPassableBlockPos.setPos(destX, y, destZ), destInto)) {
+ if (!MovementHelper.fullyPassable(context, destX, y, destZ, destInto)) {
if (i <= 3 && context.allowParkourAscend && context.canSprint && MovementHelper.canWalkOn(context, destX, y, destZ, destInto) && checkOvershootSafety(context.bsi, destX + xDiff, y + 1, destZ + zDiff)) {
res.x = destX;
res.y = y + 1;
@@ -139,7 +139,7 @@ public class MovementParkour extends Movement {
}
break;
}
-
+
// check for flat landing position
IBlockState landingOn = context.bsi.get0(destX, y - 1, destZ);
// farmland needs to be canWalkOn otherwise farm can never work at all, but we want to specifically disallow ending a jump on farmland haha
@@ -156,14 +156,14 @@ public class MovementParkour extends Movement {
}
break;
}
-
+
if (!MovementHelper.fullyPassable(context, destX, y + 3, destZ)) {
break;
}
-
+
verifiedMaxJump = i;
}
-
+
// parkour place starts here
if (!context.allowParkourPlace) {
return;
diff --git a/src/main/java/baritone/pathing/precompute/PrecomputedData.java b/src/main/java/baritone/pathing/precompute/PrecomputedData.java
index 72eb575b3..1b05bee6d 100644
--- a/src/main/java/baritone/pathing/precompute/PrecomputedData.java
+++ b/src/main/java/baritone/pathing/precompute/PrecomputedData.java
@@ -25,7 +25,7 @@ import net.minecraft.block.state.IBlockState;
import static baritone.pathing.precompute.Ternary.MAYBE;
import static baritone.pathing.precompute.Ternary.YES;
-public class PrecomputedData { // TODO add isFullyPassable
+public class PrecomputedData {
private final int[] data = new int[Block.BLOCK_STATE_IDS.size()];
@@ -34,6 +34,8 @@ public class PrecomputedData { // TODO add isFullyPassable
private static final int CAN_WALK_ON_SPECIAL_MASK = 1 << 2;
private static final int CAN_WALK_THROUGH_MASK = 1 << 3;
private static final int CAN_WALK_THROUGH_SPECIAL_MASK = 1 << 4;
+ private static final int FULLY_PASSABLE_MASK = 1 << 5;
+ private static final int FULLY_PASSABLE_SPECIAL_MASK = 1 << 6;
private int fillData(int id, IBlockState state) {
int blockData = 0;
@@ -54,6 +56,14 @@ public class PrecomputedData { // TODO add isFullyPassable
blockData |= CAN_WALK_THROUGH_SPECIAL_MASK;
}
+ Ternary fullyPassableState = MovementHelper.fullyPassableBlockState(state);
+ if (fullyPassableState == YES) {
+ blockData |= FULLY_PASSABLE_MASK;
+ }
+ if (fullyPassableState == MAYBE) {
+ blockData |= FULLY_PASSABLE_SPECIAL_MASK;
+ }
+
blockData |= COMPLETED_MASK;
data[id] = blockData; // in theory, this is thread "safe" because every thread should compute the exact same int to write?
@@ -89,4 +99,19 @@ public class PrecomputedData { // TODO add isFullyPassable
return (blockData & CAN_WALK_THROUGH_MASK) != 0;
}
}
+
+ public boolean fullyPassable(BlockStateInterface bsi, int x, int y, int z, IBlockState state) {
+ int id = Block.BLOCK_STATE_IDS.get(state);
+ int blockData = data[id];
+
+ if ((blockData & COMPLETED_MASK) == 0) { // we need to fill in the data
+ blockData = fillData(id, state);
+ }
+
+ if ((blockData & FULLY_PASSABLE_SPECIAL_MASK) != 0) {
+ return MovementHelper.fullyPassablePosition(bsi, x, y, z, state);
+ } else {
+ return (blockData & FULLY_PASSABLE_MASK) != 0;
+ }
+ }
}
From d6d9af65fbb6083ff528561065c270ccc053057f Mon Sep 17 00:00:00 2001
From: Leijurv
Date: Sun, 15 Jan 2023 01:02:52 -0800
Subject: [PATCH 67/71] reformat
---
.../command/datatypes/RelativeCoordinate.java | 4 +--
.../api/command/datatypes/RelativeFile.java | 8 ++---
.../baritone/api/pathing/goals/GoalNear.java | 2 +-
.../api/pathing/goals/GoalRunAway.java | 2 +-
.../api/schematic/SubstituteSchematic.java | 6 ++--
.../java/baritone/api/utils/SettingsUtil.java | 2 +-
.../baritone/launch/mixins/MixinItemTool.java | 3 +-
.../baritone/behavior/InventoryBehavior.java | 1 -
.../baritone/behavior/WaypointBehavior.java | 30 +++++++++----------
src/main/java/baritone/cache/WorldData.java | 1 -
.../java/baritone/cache/WorldProvider.java | 2 +-
.../baritone/command/defaults/ETACommand.java | 7 ++---
.../command/defaults/FindCommand.java | 14 ++++-----
.../baritone/command/defaults/SelCommand.java | 4 +--
.../command/defaults/WaypointsCommand.java | 4 +--
.../movement/movements/MovementTraverse.java | 2 +-
.../java/baritone/process/MineProcess.java | 8 ++---
.../java/baritone/utils/PathRenderer.java | 3 +-
src/main/java/baritone/utils/ToolSet.java | 3 +-
.../utils/schematic/SelectionSchematic.java | 10 +++----
.../format/defaults/LitematicaSchematic.java | 2 +-
21 files changed, 58 insertions(+), 60 deletions(-)
diff --git a/src/api/java/baritone/api/command/datatypes/RelativeCoordinate.java b/src/api/java/baritone/api/command/datatypes/RelativeCoordinate.java
index b8f30a774..3d0f2613f 100644
--- a/src/api/java/baritone/api/command/datatypes/RelativeCoordinate.java
+++ b/src/api/java/baritone/api/command/datatypes/RelativeCoordinate.java
@@ -27,7 +27,7 @@ import java.util.stream.Stream;
public enum RelativeCoordinate implements IDatatypePost {
INSTANCE;
private static String ScalesAliasRegex = "[kKmM]";
- private static Pattern PATTERN = Pattern.compile("^(~?)([+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)("+ScalesAliasRegex+"?)|)$");
+ private static Pattern PATTERN = Pattern.compile("^(~?)([+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(" + ScalesAliasRegex + "?)|)$");
@Override
public Double apply(IDatatypeContext ctx, Double origin) throws CommandException {
@@ -43,7 +43,7 @@ public enum RelativeCoordinate implements IDatatypePost {
boolean isRelative = !matcher.group(1).isEmpty();
double offset = matcher.group(2).isEmpty() ? 0 : Double.parseDouble(matcher.group(2).replaceAll(ScalesAliasRegex, ""));
-
+
if (matcher.group(2).toLowerCase().contains("k")) {
offset *= 1000;
}
diff --git a/src/api/java/baritone/api/command/datatypes/RelativeFile.java b/src/api/java/baritone/api/command/datatypes/RelativeFile.java
index 2c7adf98f..0bc3604ab 100644
--- a/src/api/java/baritone/api/command/datatypes/RelativeFile.java
+++ b/src/api/java/baritone/api/command/datatypes/RelativeFile.java
@@ -83,10 +83,10 @@ public enum RelativeFile implements IDatatypePost {
boolean useParent = !currentPathStringThing.isEmpty() && !currentPathStringThing.endsWith(File.separator);
File currentFile = currentPath.isAbsolute() ? currentPath.toFile() : new File(base, currentPathStringThing);
return Stream.of(Objects.requireNonNull(getCanonicalFileUnchecked(
- useParent
- ? currentFile.getParentFile()
- : currentFile
- ).listFiles()))
+ useParent
+ ? currentFile.getParentFile()
+ : currentFile
+ ).listFiles()))
.map(f -> (currentPath.isAbsolute() ? f : basePath.relativize(f.toPath()).toString()) +
(f.isDirectory() ? File.separator : ""))
.filter(s -> s.toLowerCase(Locale.US).startsWith(currentPathStringThing.toLowerCase(Locale.US)))
diff --git a/src/api/java/baritone/api/pathing/goals/GoalNear.java b/src/api/java/baritone/api/pathing/goals/GoalNear.java
index 6a8226fb4..2252446cd 100644
--- a/src/api/java/baritone/api/pathing/goals/GoalNear.java
+++ b/src/api/java/baritone/api/pathing/goals/GoalNear.java
@@ -19,8 +19,8 @@ package baritone.api.pathing.goals;
import baritone.api.utils.SettingsUtil;
import baritone.api.utils.interfaces.IGoalRenderPos;
-import it.unimi.dsi.fastutil.doubles.DoubleOpenHashSet;
import it.unimi.dsi.fastutil.doubles.DoubleIterator;
+import it.unimi.dsi.fastutil.doubles.DoubleOpenHashSet;
import net.minecraft.util.math.BlockPos;
public class GoalNear implements Goal, IGoalRenderPos {
diff --git a/src/api/java/baritone/api/pathing/goals/GoalRunAway.java b/src/api/java/baritone/api/pathing/goals/GoalRunAway.java
index 503ae7f43..b704ae4a6 100644
--- a/src/api/java/baritone/api/pathing/goals/GoalRunAway.java
+++ b/src/api/java/baritone/api/pathing/goals/GoalRunAway.java
@@ -18,8 +18,8 @@
package baritone.api.pathing.goals;
import baritone.api.utils.SettingsUtil;
-import it.unimi.dsi.fastutil.doubles.DoubleOpenHashSet;
import it.unimi.dsi.fastutil.doubles.DoubleIterator;
+import it.unimi.dsi.fastutil.doubles.DoubleOpenHashSet;
import net.minecraft.util.math.BlockPos;
import java.util.Arrays;
diff --git a/src/api/java/baritone/api/schematic/SubstituteSchematic.java b/src/api/java/baritone/api/schematic/SubstituteSchematic.java
index 72787c243..9f2013683 100644
--- a/src/api/java/baritone/api/schematic/SubstituteSchematic.java
+++ b/src/api/java/baritone/api/schematic/SubstituteSchematic.java
@@ -22,6 +22,7 @@ import net.minecraft.block.BlockAir;
import net.minecraft.block.properties.IProperty;
import net.minecraft.block.state.IBlockState;
import net.minecraft.init.Blocks;
+
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
@@ -33,7 +34,7 @@ public class SubstituteSchematic extends AbstractSchematic {
private final Map> substitutions;
private final Map> blockStateCache = new HashMap<>();
- public SubstituteSchematic(ISchematic schematic, Map> substitutions) {
+ public SubstituteSchematic(ISchematic schematic, Map> substitutions) {
super(schematic.widthX(), schematic.heightY(), schematic.lengthZ());
this.schematic = schematic;
this.substitutions = substitutions;
@@ -80,9 +81,10 @@ public class SubstituteSchematic extends AbstractSchematic {
} catch (IllegalArgumentException e) { //property does not exist for target block
}
}
- blockStateCache.computeIfAbsent(state, s -> new HashMap()).put(block, newState);
+ blockStateCache.computeIfAbsent(state, s -> new HashMap()).put(block, newState);
return newState;
}
+
private > IBlockState copySingleProp(IBlockState fromState, IBlockState toState, IProperty prop) {
return toState.withProperty(prop, fromState.getValue(prop));
}
diff --git a/src/api/java/baritone/api/utils/SettingsUtil.java b/src/api/java/baritone/api/utils/SettingsUtil.java
index 8b4b90b17..f47f515a8 100644
--- a/src/api/java/baritone/api/utils/SettingsUtil.java
+++ b/src/api/java/baritone/api/utils/SettingsUtil.java
@@ -299,7 +299,7 @@ public class SettingsUtil {
Parser keyParser = Parser.getParser(keyType);
Parser valueParser = Parser.getParser(valueType);
- return ((Map) value).entrySet().stream()
+ return ((Map) value).entrySet().stream()
.map(o -> keyParser.toString(context, o.getKey()) + "->" + valueParser.toString(context, o.getValue()))
.collect(Collectors.joining(","));
}
diff --git a/src/launch/java/baritone/launch/mixins/MixinItemTool.java b/src/launch/java/baritone/launch/mixins/MixinItemTool.java
index 4f5d025bf..8be3a837d 100644
--- a/src/launch/java/baritone/launch/mixins/MixinItemTool.java
+++ b/src/launch/java/baritone/launch/mixins/MixinItemTool.java
@@ -25,7 +25,8 @@ import org.spongepowered.asm.mixin.Shadow;
@Mixin(ItemTool.class)
public class MixinItemTool implements IItemTool {
- @Shadow protected Item.ToolMaterial toolMaterial;
+ @Shadow
+ protected Item.ToolMaterial toolMaterial;
@Override
public int getHarvestLevel() {
diff --git a/src/main/java/baritone/behavior/InventoryBehavior.java b/src/main/java/baritone/behavior/InventoryBehavior.java
index e96f1d54c..3dce5c0b5 100644
--- a/src/main/java/baritone/behavior/InventoryBehavior.java
+++ b/src/main/java/baritone/behavior/InventoryBehavior.java
@@ -18,7 +18,6 @@
package baritone.behavior;
import baritone.Baritone;
-import baritone.api.BaritoneAPI;
import baritone.api.event.events.TickEvent;
import baritone.utils.ToolSet;
import net.minecraft.block.Block;
diff --git a/src/main/java/baritone/behavior/WaypointBehavior.java b/src/main/java/baritone/behavior/WaypointBehavior.java
index b21e080e7..dfc91af82 100644
--- a/src/main/java/baritone/behavior/WaypointBehavior.java
+++ b/src/main/java/baritone/behavior/WaypointBehavior.java
@@ -71,21 +71,21 @@ public class WaypointBehavior extends Behavior {
baritone.getWorldProvider().getCurrentWorld().getWaypoints().addWaypoint(deathWaypoint);
ITextComponent component = new TextComponentString("Death position saved.");
component.getStyle()
- .setColor(TextFormatting.WHITE)
- .setHoverEvent(new HoverEvent(
- HoverEvent.Action.SHOW_TEXT,
- new TextComponentString("Click to goto death")
- ))
- .setClickEvent(new ClickEvent(
- ClickEvent.Action.RUN_COMMAND,
- String.format(
- "%s%s goto %s @ %d",
- FORCE_COMMAND_PREFIX,
- "wp",
- deathWaypoint.getTag().getName(),
- deathWaypoint.getCreationTimestamp()
- )
- ));
+ .setColor(TextFormatting.WHITE)
+ .setHoverEvent(new HoverEvent(
+ HoverEvent.Action.SHOW_TEXT,
+ new TextComponentString("Click to goto death")
+ ))
+ .setClickEvent(new ClickEvent(
+ ClickEvent.Action.RUN_COMMAND,
+ String.format(
+ "%s%s goto %s @ %d",
+ FORCE_COMMAND_PREFIX,
+ "wp",
+ deathWaypoint.getTag().getName(),
+ deathWaypoint.getCreationTimestamp()
+ )
+ ));
Helper.HELPER.logDirect(component);
}
diff --git a/src/main/java/baritone/cache/WorldData.java b/src/main/java/baritone/cache/WorldData.java
index cbdda3687..5a9ab389d 100644
--- a/src/main/java/baritone/cache/WorldData.java
+++ b/src/main/java/baritone/cache/WorldData.java
@@ -22,7 +22,6 @@ import baritone.api.cache.ICachedWorld;
import baritone.api.cache.IWaypointCollection;
import baritone.api.cache.IWorldData;
-import java.io.IOException;
import java.nio.file.Path;
/**
diff --git a/src/main/java/baritone/cache/WorldProvider.java b/src/main/java/baritone/cache/WorldProvider.java
index 98ec1bbb2..97b15a137 100644
--- a/src/main/java/baritone/cache/WorldProvider.java
+++ b/src/main/java/baritone/cache/WorldProvider.java
@@ -23,8 +23,8 @@ import baritone.api.utils.Helper;
import baritone.utils.accessor.IAnvilChunkLoader;
import baritone.utils.accessor.IChunkProviderServer;
import net.minecraft.server.integrated.IntegratedServer;
-import net.minecraft.world.WorldServer;
import net.minecraft.world.World;
+import net.minecraft.world.WorldServer;
import org.apache.commons.lang3.SystemUtils;
import java.io.File;
diff --git a/src/main/java/baritone/command/defaults/ETACommand.java b/src/main/java/baritone/command/defaults/ETACommand.java
index 47b6ae9fa..4116d65b0 100644
--- a/src/main/java/baritone/command/defaults/ETACommand.java
+++ b/src/main/java/baritone/command/defaults/ETACommand.java
@@ -18,17 +18,16 @@
package baritone.command.defaults;
import baritone.api.IBaritone;
-import baritone.api.pathing.calc.IPathingControlManager;
-import baritone.api.process.IBaritoneProcess;
import baritone.api.behavior.IPathingBehavior;
import baritone.api.command.Command;
+import baritone.api.command.argument.IArgConsumer;
import baritone.api.command.exception.CommandException;
import baritone.api.command.exception.CommandInvalidStateException;
-import baritone.api.command.argument.IArgConsumer;
+import baritone.api.pathing.calc.IPathingControlManager;
+import baritone.api.process.IBaritoneProcess;
import java.util.Arrays;
import java.util.List;
-import java.util.Optional;
import java.util.stream.Stream;
public class ETACommand extends Command {
diff --git a/src/main/java/baritone/command/defaults/FindCommand.java b/src/main/java/baritone/command/defaults/FindCommand.java
index b20f14e98..2063d9300 100644
--- a/src/main/java/baritone/command/defaults/FindCommand.java
+++ b/src/main/java/baritone/command/defaults/FindCommand.java
@@ -79,10 +79,10 @@ public class FindCommand extends Command {
ITextComponent baseComponent = new TextComponentString(pos.toString());
ITextComponent hoverComponent = new TextComponentString("Click to set goal to this position");
baseComponent.getStyle()
- .setColor(TextFormatting.GRAY)
- .setInsertion(positionText)
- .setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, command))
- .setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, hoverComponent));
+ .setColor(TextFormatting.GRAY)
+ .setInsertion(positionText)
+ .setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, command))
+ .setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, hoverComponent));
return baseComponent;
}
@@ -90,9 +90,9 @@ public class FindCommand extends Command {
public Stream tabComplete(String label, IArgConsumer args) throws CommandException {
return new TabCompleteHelper()
.append(
- CachedChunk.BLOCKS_TO_KEEP_TRACK_OF.stream()
- .map(Block.REGISTRY::getNameForObject)
- .map(Object::toString)
+ CachedChunk.BLOCKS_TO_KEEP_TRACK_OF.stream()
+ .map(Block.REGISTRY::getNameForObject)
+ .map(Object::toString)
)
.filterPrefixNamespaced(args.getString())
.sortAlphabetically()
diff --git a/src/main/java/baritone/command/defaults/SelCommand.java b/src/main/java/baritone/command/defaults/SelCommand.java
index 659a31835..5677eec3c 100644
--- a/src/main/java/baritone/command/defaults/SelCommand.java
+++ b/src/main/java/baritone/command/defaults/SelCommand.java
@@ -36,8 +36,8 @@ import baritone.api.selection.ISelectionManager;
import baritone.api.utils.BetterBlockPos;
import baritone.api.utils.BlockOptionalMeta;
import baritone.api.utils.BlockOptionalMetaLookup;
-import baritone.utils.IRenderer;
import baritone.utils.BlockStateInterface;
+import baritone.utils.IRenderer;
import baritone.utils.schematic.StaticSchematic;
import net.minecraft.block.state.IBlockState;
import net.minecraft.init.Blocks;
@@ -193,7 +193,7 @@ public class SelCommand extends Command {
}
}
}
- ISchematic schematic = new StaticSchematic(){{
+ ISchematic schematic = new StaticSchematic() {{
states = blockstates;
x = size.getX();
y = size.getY();
diff --git a/src/main/java/baritone/command/defaults/WaypointsCommand.java b/src/main/java/baritone/command/defaults/WaypointsCommand.java
index 5a45686a3..cf420e90a 100644
--- a/src/main/java/baritone/command/defaults/WaypointsCommand.java
+++ b/src/main/java/baritone/command/defaults/WaypointsCommand.java
@@ -20,8 +20,8 @@ package baritone.command.defaults;
import baritone.Baritone;
import baritone.api.IBaritone;
import baritone.api.cache.IWaypoint;
-import baritone.api.cache.Waypoint;
import baritone.api.cache.IWorldData;
+import baritone.api.cache.Waypoint;
import baritone.api.command.Command;
import baritone.api.command.argument.IArgConsumer;
import baritone.api.command.datatypes.ForWaypoints;
@@ -50,7 +50,7 @@ import static baritone.api.command.IBaritoneChatControl.FORCE_COMMAND_PREFIX;
public class WaypointsCommand extends Command {
- private Map> deletedWaypoints = new HashMap<>();
+ private Map> deletedWaypoints = new HashMap<>();
public WaypointsCommand(IBaritone baritone) {
super(baritone, "waypoints", "waypoint", "wp");
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
index c8a3528ee..1d79b0514 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
@@ -73,7 +73,7 @@ public class MovementTraverse extends Movement {
IBlockState destOn = context.get(destX, y - 1, destZ);
IBlockState srcDown = context.get(x, y - 1, z);
Block srcDownBlock = srcDown.getBlock();
- boolean standingOnABlock = MovementHelper.mustBeSolidToWalkOn(context, x, y-1, z, srcDown);
+ boolean standingOnABlock = MovementHelper.mustBeSolidToWalkOn(context, x, y - 1, z, srcDown);
boolean frostWalker = standingOnABlock && !context.assumeWalkOnWater && MovementHelper.canUseFrostWalker(context, destOn);
if (frostWalker || MovementHelper.canWalkOn(context, destX, y - 1, destZ, destOn)) { //this is a walk, not a bridge
double WC = WALK_ONE_BLOCK_COST;
diff --git a/src/main/java/baritone/process/MineProcess.java b/src/main/java/baritone/process/MineProcess.java
index e79cb815b..34f5c4c35 100644
--- a/src/main/java/baritone/process/MineProcess.java
+++ b/src/main/java/baritone/process/MineProcess.java
@@ -28,7 +28,6 @@ import baritone.cache.CachedChunk;
import baritone.cache.WorldScanner;
import baritone.pathing.movement.CalculationContext;
import baritone.pathing.movement.MovementHelper;
-import baritone.pathing.precompute.PrecomputedData;
import baritone.utils.BaritoneProcessHelper;
import baritone.utils.BlockStateInterface;
import net.minecraft.block.Block;
@@ -215,6 +214,7 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
public boolean isInGoal(int x, int y, int z) {
return false;
}
+
@Override
public double heuristic() {
return Double.NEGATIVE_INFINITY;
@@ -500,9 +500,9 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
}
if (!Baritone.settings().allowBreak.value) {
BlockOptionalMetaLookup f = new BlockOptionalMetaLookup(this.filter.blocks()
- .stream()
- .filter(e -> Baritone.settings().allowBreakAnyway.value.contains(e.getBlock()))
- .toArray(BlockOptionalMeta[]::new));
+ .stream()
+ .filter(e -> Baritone.settings().allowBreakAnyway.value.contains(e.getBlock()))
+ .toArray(BlockOptionalMeta[]::new));
if (f.blocks().isEmpty()) {
logDirect("Unable to mine when allowBreak is false and target block is not in allowBreakAnyway!");
return null;
diff --git a/src/main/java/baritone/utils/PathRenderer.java b/src/main/java/baritone/utils/PathRenderer.java
index de29bca43..2fe224706 100644
--- a/src/main/java/baritone/utils/PathRenderer.java
+++ b/src/main/java/baritone/utils/PathRenderer.java
@@ -211,8 +211,7 @@ public final class PathRenderer implements IRenderer {
if (!settings.renderGoalAnimated.value) {
// y = 1 causes rendering issues when the player is at the same y as the top of a block for some reason
y = 0.999F;
- }
- else {
+ } else {
y = MathHelper.cos((float) (((float) ((System.nanoTime() / 100000L) % 20000L)) / 20000F * Math.PI * 2));
}
if (goal instanceof IGoalRenderPos) {
diff --git a/src/main/java/baritone/utils/ToolSet.java b/src/main/java/baritone/utils/ToolSet.java
index 0ad4665d6..61f11e563 100644
--- a/src/main/java/baritone/utils/ToolSet.java
+++ b/src/main/java/baritone/utils/ToolSet.java
@@ -25,7 +25,6 @@ import net.minecraft.client.entity.EntityPlayerSP;
import net.minecraft.enchantment.EnchantmentHelper;
import net.minecraft.init.Enchantments;
import net.minecraft.init.MobEffects;
-import net.minecraft.item.Item.ToolMaterial;
import net.minecraft.item.ItemStack;
import net.minecraft.item.ItemSword;
import net.minecraft.item.ItemTool;
@@ -130,7 +129,7 @@ public class ToolSet {
if (!Baritone.settings().useSwordToMine.value && itemStack.getItem() instanceof ItemSword) {
continue;
}
-
+
if (Baritone.settings().itemSaver.value && (itemStack.getItemDamage() + Baritone.settings().itemSaverThreshold.value) >= itemStack.getMaxDamage() && itemStack.getMaxDamage() > 1) {
continue;
}
diff --git a/src/main/java/baritone/utils/schematic/SelectionSchematic.java b/src/main/java/baritone/utils/schematic/SelectionSchematic.java
index 243a3d4d0..156a80918 100644
--- a/src/main/java/baritone/utils/schematic/SelectionSchematic.java
+++ b/src/main/java/baritone/utils/schematic/SelectionSchematic.java
@@ -33,10 +33,10 @@ public class SelectionSchematic extends MaskSchematic {
public SelectionSchematic(ISchematic schematic, Vec3i origin, ISelection[] selections) {
super(schematic);
this.selections = Stream.of(selections).map(
- sel -> sel
- .shift(EnumFacing.WEST, origin.getX())
- .shift(EnumFacing.DOWN, origin.getY())
- .shift(EnumFacing.NORTH, origin.getZ()))
+ sel -> sel
+ .shift(EnumFacing.WEST, origin.getX())
+ .shift(EnumFacing.DOWN, origin.getY())
+ .shift(EnumFacing.NORTH, origin.getZ()))
.toArray(ISelection[]::new);
}
@@ -44,7 +44,7 @@ public class SelectionSchematic extends MaskSchematic {
protected boolean partOfMask(int x, int y, int z, IBlockState currentState) {
for (ISelection selection : selections) {
if (x >= selection.min().x && y >= selection.min().y && z >= selection.min().z
- && x <= selection.max().x && y <= selection.max().y && z <= selection.max().z) {
+ && x <= selection.max().x && y <= selection.max().y && z <= selection.max().z) {
return true;
}
}
diff --git a/src/main/java/baritone/utils/schematic/format/defaults/LitematicaSchematic.java b/src/main/java/baritone/utils/schematic/format/defaults/LitematicaSchematic.java
index c2857bc2d..7ff737ebc 100644
--- a/src/main/java/baritone/utils/schematic/format/defaults/LitematicaSchematic.java
+++ b/src/main/java/baritone/utils/schematic/format/defaults/LitematicaSchematic.java
@@ -136,7 +136,7 @@ public final class LitematicaSchematic extends StaticSchematic {
* @return amount of bits used to encode a block.
*/
private static int getBitsPerBlock(int amountOfBlockTypes) {
- return (int) Math.max(2,Math.ceil(Math.log(amountOfBlockTypes) / Math.log(2)));
+ return (int) Math.max(2, Math.ceil(Math.log(amountOfBlockTypes) / Math.log(2)));
}
/**
From aa9206381dfd98c3e9363d20204d767e9ff713a5 Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Sun, 15 Jan 2023 14:53:04 +0100
Subject: [PATCH 68/71] Fix canWalkThrough caching
---
src/main/java/baritone/pathing/precompute/PrecomputedData.java | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/main/java/baritone/pathing/precompute/PrecomputedData.java b/src/main/java/baritone/pathing/precompute/PrecomputedData.java
index 1b05bee6d..bf00ee087 100644
--- a/src/main/java/baritone/pathing/precompute/PrecomputedData.java
+++ b/src/main/java/baritone/pathing/precompute/PrecomputedData.java
@@ -52,7 +52,7 @@ public class PrecomputedData {
if (canWalkThroughState == YES) {
blockData |= CAN_WALK_THROUGH_MASK;
}
- if (canWalkOnState == MAYBE) {
+ if (canWalkThroughState == MAYBE) {
blockData |= CAN_WALK_THROUGH_SPECIAL_MASK;
}
From 432d42ade864715f85d7758238a68de57f2f3419 Mon Sep 17 00:00:00 2001
From: ZacSharp <68165024+ZacSharp@users.noreply.github.com>
Date: Sun, 15 Jan 2023 20:22:58 +0100
Subject: [PATCH 69/71] Fix #find results not being clickable
---
.../baritone/command/defaults/FindCommand.java | 14 +++++++-------
1 file changed, 7 insertions(+), 7 deletions(-)
diff --git a/src/main/java/baritone/command/defaults/FindCommand.java b/src/main/java/baritone/command/defaults/FindCommand.java
index 1bc454b82..00810218d 100644
--- a/src/main/java/baritone/command/defaults/FindCommand.java
+++ b/src/main/java/baritone/command/defaults/FindCommand.java
@@ -75,13 +75,13 @@ public class FindCommand extends Command {
private ITextComponent positionToComponent(BetterBlockPos pos) {
String positionText = String.format("%s %s %s", pos.x, pos.y, pos.z);
String command = String.format("%sgoal %s", FORCE_COMMAND_PREFIX, positionText);
- ITextComponent baseComponent = new StringTextComponent(pos.toString());
- ITextComponent hoverComponent = new StringTextComponent("Click to set goal to this position");
- baseComponent.getStyle()
- .setColor(Color.fromTextFormatting(TextFormatting.GRAY))
- .setInsertion(positionText)
- .setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, command))
- .setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, hoverComponent));
+ IFormattableTextComponent baseComponent = new StringTextComponent(pos.toString());
+ IFormattableTextComponent hoverComponent = new StringTextComponent("Click to set goal to this position");
+ baseComponent.setStyle(baseComponent.getStyle()
+ .setFormatting(TextFormatting.GRAY)
+ .setInsertion(positionText)
+ .setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, command))
+ .setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, hoverComponent)));
return baseComponent;
}
From 2b6c59fa8a1efac1a105a2ab2077914f4869db0d Mon Sep 17 00:00:00 2001
From: Leijurv
Date: Mon, 16 Jan 2023 12:22:52 -0800
Subject: [PATCH 70/71] v1.2.17
---
build.gradle | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/build.gradle b/build.gradle
index 67c303265..0ce05058c 100755
--- a/build.gradle
+++ b/build.gradle
@@ -16,7 +16,7 @@
*/
group 'baritone'
-version '1.2.16'
+version '1.2.17'
buildscript {
repositories {
From 698d40d7978b5cb115db68c7ac0bffd949708958 Mon Sep 17 00:00:00 2001
From: leijurv
Date: Mon, 16 Jan 2023 20:55:43 -0800
Subject: [PATCH 71/71] bump
---
README.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/README.md b/README.md
index 1b5c70935..e2c83ddec 100644
--- a/README.md
+++ b/README.md
@@ -56,7 +56,7 @@ Baritone is the pathfinding system used in [Impact](https://impactclient.net/) s
The easiest way to install Baritone is to install [Impact](https://impactclient.net/), which comes with Baritone. The second easiest way (for 1.12.2 only) is to
install the v1.2.* `api-forge` jar from [releases](https://github.com/cabaletta/baritone/releases). **For 1.12.2 Forge, just click
-[here](https://github.com/cabaletta/baritone/releases/download/v1.2.16/baritone-api-forge-1.2.16.jar)**. Otherwise, see [Installation & setup](SETUP.md). Once Baritone is installed, look [here](USAGE.md) for instructions on how to use it.
+[here](https://github.com/cabaletta/baritone/releases/download/v1.2.17/baritone-api-forge-1.2.17.jar)**. Otherwise, see [Installation & setup](SETUP.md). Once Baritone is installed, look [here](USAGE.md) for instructions on how to use it.
For 1.16.5, [click here](https://www.youtube.com/watch?v=_4eVJ9Qz2J8) and see description. If you need Forge or Fabric 1.16.5, look [here](https://github.com/cabaletta/baritone/releases/tag/v1.6.3) and get the `api-forge` or `api-fabric` jar. **For 1.16.5 Fabric, just click [here](https://github.com/cabaletta/baritone/releases/download/v1.6.3/baritone-api-fabric-1.6.3.jar)**.