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/23] 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 cc7b4226..a29e06bb 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/23] 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 a29e06bb..4a45cd99 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/23] 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 4a45cd99..c96dee78 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/23] 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 c96dee78..b121a0b3 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/23] 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 b121a0b3..f915dd78 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/23] 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 99a25944..6d3a742c 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/23] 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 6d3a742c..3ca2c466 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/23] 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 f915dd78..3d115d1d 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 3ca2c466..5b5bbc52 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 00000000..d4d8424e
--- /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/23] 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 5b5bbc52..72eb575b 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/23] 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 3d115d1d..0b6d7e34 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/23] 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 0b6d7e34..e3fc6a03 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;