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/35] 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/35] 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/35] 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/35] 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/35] 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/35] 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/35] 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/35] 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/35] 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/35] 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/35] 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/35] 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 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 25/35] =?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 26/35] 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 27/35] 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 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 28/35] 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 29/35] 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 30/35] 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 31/35] 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 32/35] 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 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 33/35] 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 34/35] 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 35/35] 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'