From dab70926e2d003b6c613f7ad7ef74ed38da598b3 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Wed, 22 Aug 2018 16:56:05 -0700 Subject: [PATCH 01/86] waypoints --- src/main/java/baritone/chunk/Waypoint.java | 74 +++++++++++++++++++ src/main/java/baritone/chunk/Waypoints.java | 82 ++++++++++++++++++++- src/main/java/baritone/chunk/WorldData.java | 5 ++ 3 files changed, 160 insertions(+), 1 deletion(-) create mode 100644 src/main/java/baritone/chunk/Waypoint.java diff --git a/src/main/java/baritone/chunk/Waypoint.java b/src/main/java/baritone/chunk/Waypoint.java new file mode 100644 index 00000000..495608ba --- /dev/null +++ b/src/main/java/baritone/chunk/Waypoint.java @@ -0,0 +1,74 @@ +/* + * This file is part of Baritone. + * + * Baritone is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Baritone. If not, see . + */ + +package baritone.chunk; + +import net.minecraft.util.math.BlockPos; + +import java.util.HashMap; +import java.util.Map; + +/** + * A single waypoint + * + * @author leijurv + */ +public class Waypoint { + public final String name; + public final Tag tag; + public final long creationTimestamp; + public final BlockPos location; + + public Waypoint(String name, Tag tag, BlockPos location) { + this(name, tag, location, System.currentTimeMillis()); + } + + Waypoint(String name, Tag tag, BlockPos location, long creationTimestamp) { // read from disk + this.name = name; + this.tag = tag; + this.location = location; + this.creationTimestamp = creationTimestamp; + } + + @Override + public boolean equals(Object o) { + if (o == null) { + return false; + } + if (!(o instanceof Waypoint)) { + return false; + } + Waypoint w = (Waypoint) o; + return name.equals(w.name) && tag == w.tag && creationTimestamp == w.creationTimestamp && location.equals(w.location); + } + + @Override + public int hashCode() { + return name.hashCode() + tag.hashCode() + (int) creationTimestamp + location.hashCode(); //lol + } + + public enum Tag { + HOME, DEATH, USER; + + { + map.put(name().toLowerCase(), this); + } + + } + + private static final Map map = new HashMap<>(); +} diff --git a/src/main/java/baritone/chunk/Waypoints.java b/src/main/java/baritone/chunk/Waypoints.java index 4617ad63..255ac03d 100644 --- a/src/main/java/baritone/chunk/Waypoints.java +++ b/src/main/java/baritone/chunk/Waypoints.java @@ -17,12 +17,21 @@ package baritone.chunk; -import java.io.IOException; +import net.minecraft.util.math.BlockPos; + +import java.io.*; import java.nio.file.Files; import java.nio.file.Path; +import java.util.*; +/** + * Waypoints for a world + * + * @author leijurv + */ public class Waypoints { private final Path directory; + private final Map> waypoints; Waypoints(Path directory) { this.directory = directory; @@ -32,5 +41,76 @@ public class Waypoints { } catch (IOException ignored) {} } System.out.println("Would save waypoints to " + directory); + this.waypoints = new HashMap<>(); + load(); + } + + private void load() { + for (Waypoint.Tag tag : Waypoint.Tag.values()) { + load(tag); + } + } + + private synchronized void load(Waypoint.Tag tag) { + waypoints.put(tag, new HashSet<>()); + + Path fileName = directory.resolve(tag.name().toLowerCase()); + if (!Files.exists(fileName)) + return; + + try ( + FileInputStream fileIn = new FileInputStream(fileName.toFile()); + BufferedInputStream bufIn = new BufferedInputStream(fileIn); + DataInputStream in = new DataInputStream(bufIn); + ) { + while (true) { + String name = in.readUTF(); + long creationTimestamp = in.readLong(); + int x = in.readInt(); + int y = in.readInt(); + int z = in.readInt(); + waypoints.get(tag).add(new Waypoint(name, tag, new BlockPos(x, y, z), creationTimestamp)); + } + } catch (IOException ex) { } + } + + private synchronized void save(Waypoint.Tag tag) { + Path fileName = directory.resolve(tag.name().toLowerCase()); + try ( + FileOutputStream fileOut = new FileOutputStream(fileName.toFile()); + BufferedOutputStream bufOut = new BufferedOutputStream(fileOut); + DataOutputStream out = new DataOutputStream(bufOut); + ) { + for (Waypoint waypoint : waypoints.get(tag)) { + out.writeUTF(waypoint.name); + out.writeLong(waypoint.creationTimestamp); + out.writeInt(waypoint.location.getX()); + out.writeInt(waypoint.location.getY()); + out.writeInt(waypoint.location.getZ()); + } + } catch (IOException ex) { + ex.printStackTrace(); + } + } + + public Set getByTag(Waypoint.Tag tag) { + return Collections.unmodifiableSet(waypoints.get(tag)); + } + + public Waypoint getMostRecentByTag(Waypoint.Tag tag) { + Set pts = waypoints.get(tag); + Waypoint best = null; + for (Waypoint waypoint : pts) { + if (best == null || waypoint.creationTimestamp > best.creationTimestamp) { + best = waypoint; + } + } + return best; + } + + public void addWaypoint(Waypoint waypoint) { + // no need to check for duplicate, because it's a Set not a List + waypoints.get(waypoint.tag).add(waypoint); + save(waypoint.tag); } } diff --git a/src/main/java/baritone/chunk/WorldData.java b/src/main/java/baritone/chunk/WorldData.java index 7145742e..3cd7b737 100644 --- a/src/main/java/baritone/chunk/WorldData.java +++ b/src/main/java/baritone/chunk/WorldData.java @@ -19,6 +19,11 @@ package baritone.chunk; import java.nio.file.Path; +/** + * Data about a world, from baritone's point of view. Includes cached chunks, waypoints, and map data. + * + * @author leijurv + */ public class WorldData { public final CachedWorld cache; public final Waypoints waypoints; From 4bf1c7983066043149914388cc600ad7f110d090 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Wed, 22 Aug 2018 17:49:55 -0700 Subject: [PATCH 02/86] home and sethome, fixes #54 --- .../utils/ExampleBaritoneControl.java | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/src/main/java/baritone/utils/ExampleBaritoneControl.java b/src/main/java/baritone/utils/ExampleBaritoneControl.java index 63a3110c..de1ced27 100644 --- a/src/main/java/baritone/utils/ExampleBaritoneControl.java +++ b/src/main/java/baritone/utils/ExampleBaritoneControl.java @@ -21,6 +21,8 @@ import baritone.Baritone; import baritone.Settings; import baritone.behavior.Behavior; import baritone.behavior.impl.PathingBehavior; +import baritone.chunk.Waypoint; +import baritone.chunk.WorldProvider; import baritone.event.events.ChatEvent; import baritone.pathing.calc.AStarPathFinder; import baritone.pathing.goals.Goal; @@ -122,6 +124,24 @@ public class ExampleBaritoneControl extends Behavior { event.cancel(); return; } + if (msg.toLowerCase().equals("sethome")) { + WorldProvider.INSTANCE.getCurrentWorld().waypoints.addWaypoint(new Waypoint("", Waypoint.Tag.HOME, playerFeet())); + displayChatMessageRaw("Saved. Say home to set goal."); + event.cancel(); + return; + } + if (msg.toLowerCase().equals("home")) { + Waypoint waypoint = WorldProvider.INSTANCE.getCurrentWorld().waypoints.getMostRecentByTag(Waypoint.Tag.HOME); + if (waypoint == null) { + displayChatMessageRaw("home not saved"); + } else { + Goal goal = new GoalBlock(waypoint.location); + PathingBehavior.INSTANCE.setGoal(goal); + displayChatMessageRaw("Set goal to " + goal); + } + event.cancel(); + return; + } if (msg.toLowerCase().equals("costs")) { Movement[] movements = AStarPathFinder.getConnectedPositions(new BetterBlockPos(playerFeet()), new CalculationContext()); ArrayList moves = new ArrayList<>(Arrays.asList(movements)); From fcb947bedcb2fc0a1a24e91ee8a54c743cd6001c Mon Sep 17 00:00:00 2001 From: Leijurv Date: Wed, 22 Aug 2018 17:56:08 -0700 Subject: [PATCH 03/86] bed --- src/main/java/baritone/chunk/Waypoint.java | 2 +- .../utils/ExampleBaritoneControl.java | 21 ++++++++++++------- 2 files changed, 15 insertions(+), 8 deletions(-) diff --git a/src/main/java/baritone/chunk/Waypoint.java b/src/main/java/baritone/chunk/Waypoint.java index 495608ba..d834ee2c 100644 --- a/src/main/java/baritone/chunk/Waypoint.java +++ b/src/main/java/baritone/chunk/Waypoint.java @@ -62,7 +62,7 @@ public class Waypoint { } public enum Tag { - HOME, DEATH, USER; + HOME, DEATH, BED, USER; { map.put(name().toLowerCase(), this); diff --git a/src/main/java/baritone/utils/ExampleBaritoneControl.java b/src/main/java/baritone/utils/ExampleBaritoneControl.java index de1ced27..fae6a4d8 100644 --- a/src/main/java/baritone/utils/ExampleBaritoneControl.java +++ b/src/main/java/baritone/utils/ExampleBaritoneControl.java @@ -115,12 +115,19 @@ public class ExampleBaritoneControl extends Behavior { event.cancel(); return; } - if (msg.toLowerCase().equals("spawn")) { - BlockPos spawnPoint = player().getBedLocation(); - // for some reason the default spawnpoint is underground sometimes - Goal goal = new GoalXZ(spawnPoint.getX(), spawnPoint.getY()); - PathingBehavior.INSTANCE.setGoal(goal); - displayChatMessageRaw("Goal: " + goal); + if (msg.toLowerCase().equals("spawn") || msg.toLowerCase().equals("bed")) { + Waypoint waypoint = WorldProvider.INSTANCE.getCurrentWorld().waypoints.getMostRecentByTag(Waypoint.Tag.BED); + if (waypoint == null) { + BlockPos spawnPoint = player().getBedLocation(); + // for some reason the default spawnpoint is underground sometimes + Goal goal = new GoalXZ(spawnPoint.getX(), spawnPoint.getZ()); + displayChatMessageRaw("spawn not saved, defaulting to world spawn. set goal to " + goal); + PathingBehavior.INSTANCE.setGoal(goal); + } else { + Goal goal = new GoalBlock(waypoint.location); + PathingBehavior.INSTANCE.setGoal(goal); + displayChatMessageRaw("Set goal to most recent bed " + goal); + } event.cancel(); return; } @@ -137,7 +144,7 @@ public class ExampleBaritoneControl extends Behavior { } else { Goal goal = new GoalBlock(waypoint.location); PathingBehavior.INSTANCE.setGoal(goal); - displayChatMessageRaw("Set goal to " + goal); + displayChatMessageRaw("Set goal to saved home " + goal); } event.cancel(); return; From 060eeb97377289a58815b7bdb4341b393ead8dbd Mon Sep 17 00:00:00 2001 From: Brady Date: Wed, 22 Aug 2018 21:04:37 -0500 Subject: [PATCH 04/86] Add automatic bed waypoints on interact, fixes #79 --- .../behavior/impl/MemoryBehavior.java | 12 ++++ src/main/java/baritone/chunk/Waypoints.java | 4 +- .../java/baritone/event/GameEventHandler.java | 5 ++ .../event/events/BlockInteractEvent.java | 69 +++++++++++++++++++ .../listener/AbstractGameEventListener.java | 3 + .../event/listener/IGameEventListener.java | 8 +++ .../launch/mixins/MixinMinecraft.java | 29 ++++++++ 7 files changed, 128 insertions(+), 2 deletions(-) create mode 100644 src/main/java/baritone/event/events/BlockInteractEvent.java diff --git a/src/main/java/baritone/behavior/impl/MemoryBehavior.java b/src/main/java/baritone/behavior/impl/MemoryBehavior.java index ed5bd686..f8009c43 100644 --- a/src/main/java/baritone/behavior/impl/MemoryBehavior.java +++ b/src/main/java/baritone/behavior/impl/MemoryBehavior.java @@ -1,9 +1,14 @@ package baritone.behavior.impl; import baritone.behavior.Behavior; +import baritone.chunk.Waypoint; +import baritone.chunk.WorldProvider; +import baritone.event.events.BlockInteractEvent; import baritone.event.events.PacketEvent; import baritone.event.events.PlayerUpdateEvent; import baritone.event.events.type.EventState; +import baritone.utils.BlockStateInterface; +import net.minecraft.block.BlockBed; import net.minecraft.item.ItemStack; import net.minecraft.network.Packet; import net.minecraft.network.play.client.CPacketCloseWindow; @@ -104,6 +109,13 @@ public class MemoryBehavior extends Behavior { } } + @Override + public void onBlockInteract(BlockInteractEvent event) { + if (event.getType() == BlockInteractEvent.Type.USE && BlockStateInterface.get(event.getPos()) instanceof BlockBed) { + WorldProvider.INSTANCE.getCurrentWorld().waypoints.addWaypoint(new Waypoint("bed", Waypoint.Tag.BED, playerFeet())); + } + } + private Optional getInventoryFromWindow(int windowId) { return this.rememberedInventories.values().stream().filter(i -> i.windowId == windowId).findFirst(); } diff --git a/src/main/java/baritone/chunk/Waypoints.java b/src/main/java/baritone/chunk/Waypoints.java index 255ac03d..2ad7f16d 100644 --- a/src/main/java/baritone/chunk/Waypoints.java +++ b/src/main/java/baritone/chunk/Waypoints.java @@ -61,7 +61,7 @@ public class Waypoints { try ( FileInputStream fileIn = new FileInputStream(fileName.toFile()); BufferedInputStream bufIn = new BufferedInputStream(fileIn); - DataInputStream in = new DataInputStream(bufIn); + DataInputStream in = new DataInputStream(bufIn) ) { while (true) { String name = in.readUTF(); @@ -71,7 +71,7 @@ public class Waypoints { int z = in.readInt(); waypoints.get(tag).add(new Waypoint(name, tag, new BlockPos(x, y, z), creationTimestamp)); } - } catch (IOException ex) { } + } catch (IOException ignored) {} } private synchronized void save(Waypoint.Tag tag) { diff --git a/src/main/java/baritone/event/GameEventHandler.java b/src/main/java/baritone/event/GameEventHandler.java index c6ab20fd..c61201bf 100644 --- a/src/main/java/baritone/event/GameEventHandler.java +++ b/src/main/java/baritone/event/GameEventHandler.java @@ -174,6 +174,11 @@ public final class GameEventHandler implements IGameEventListener, Helper { dispatch(listener -> listener.onPlayerRelativeMove(event)); } + @Override + public void onBlockInteract(BlockInteractEvent event) { + dispatch(listener -> listener.onBlockInteract(event)); + } + public final void registerEventListener(IGameEventListener listener) { this.listeners.add(listener); } diff --git a/src/main/java/baritone/event/events/BlockInteractEvent.java b/src/main/java/baritone/event/events/BlockInteractEvent.java new file mode 100644 index 00000000..c458f6b6 --- /dev/null +++ b/src/main/java/baritone/event/events/BlockInteractEvent.java @@ -0,0 +1,69 @@ +/* + * This file is part of Baritone. + * + * Baritone is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Baritone. If not, see . + */ + +package baritone.event.events; + +import net.minecraft.util.math.BlockPos; + +/** + * @author Brady + * @since 8/22/2018 + */ +public final class BlockInteractEvent { + + /** + * The position of the block interacted with + */ + private final BlockPos pos; + + /** + * The type of interaction that occurred + */ + private final Type type; + + public BlockInteractEvent(BlockPos pos, Type type) { + this.pos = pos; + this.type = type; + } + + /** + * @return The position of the block interacted with + */ + public final BlockPos getPos() { + return this.pos; + } + + /** + * @return The type of interaction with the target block + */ + public final Type getType() { + return this.type; + } + + public enum Type { + + /** + * We're breaking the target block. + */ + BREAK, + + /** + * We're right clicking on the target block. Either placing or interacting with. + */ + USE + } +} diff --git a/src/main/java/baritone/event/listener/AbstractGameEventListener.java b/src/main/java/baritone/event/listener/AbstractGameEventListener.java index 46cbeb65..4f940c38 100644 --- a/src/main/java/baritone/event/listener/AbstractGameEventListener.java +++ b/src/main/java/baritone/event/listener/AbstractGameEventListener.java @@ -80,4 +80,7 @@ public interface AbstractGameEventListener extends IGameEventListener { @Override default void onPlayerRelativeMove(RelativeMoveEvent event) {} + + @Override + default void onBlockInteract(BlockInteractEvent event) {} } diff --git a/src/main/java/baritone/event/listener/IGameEventListener.java b/src/main/java/baritone/event/listener/IGameEventListener.java index 7d239133..1958f0c3 100644 --- a/src/main/java/baritone/event/listener/IGameEventListener.java +++ b/src/main/java/baritone/event/listener/IGameEventListener.java @@ -132,4 +132,12 @@ public interface IGameEventListener { * @see Entity#moveRelative(float, float, float, float) */ void onPlayerRelativeMove(RelativeMoveEvent event); + + /** + * Called when the local player interacts with a block, whether it is breaking or opening/placing. + * + * @see Minecraft#clickMouse() + * @see Minecraft#rightClickMouse() + */ + void onBlockInteract(BlockInteractEvent event); } diff --git a/src/main/java/baritone/launch/mixins/MixinMinecraft.java b/src/main/java/baritone/launch/mixins/MixinMinecraft.java index 1c14d179..487f126f 100755 --- a/src/main/java/baritone/launch/mixins/MixinMinecraft.java +++ b/src/main/java/baritone/launch/mixins/MixinMinecraft.java @@ -19,6 +19,7 @@ package baritone.launch.mixins; import baritone.Baritone; import baritone.behavior.impl.PathingBehavior; +import baritone.event.events.BlockInteractEvent; import baritone.event.events.TickEvent; import baritone.event.events.WorldEvent; import baritone.event.events.type.EventState; @@ -26,6 +27,10 @@ import baritone.utils.ExampleBaritoneControl; import net.minecraft.client.Minecraft; import net.minecraft.client.gui.GuiScreen; import net.minecraft.client.multiplayer.WorldClient; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumActionResult; +import net.minecraft.util.EnumHand; +import net.minecraft.util.math.BlockPos; import org.spongepowered.asm.lib.Opcodes; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.Shadow; @@ -33,6 +38,7 @@ import org.spongepowered.asm.mixin.injection.At; import org.spongepowered.asm.mixin.injection.Inject; import org.spongepowered.asm.mixin.injection.Redirect; import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; +import org.spongepowered.asm.mixin.injection.callback.LocalCapture; /** * @author Brady @@ -155,4 +161,27 @@ public class MixinMinecraft { private boolean isAllowUserInput(GuiScreen screen) { return PathingBehavior.INSTANCE.getCurrent() != null || screen.allowUserInput; } + + @Inject( + method = "clickMouse", + at = @At( + value = "INVOKE", + target = "net/minecraft/client/multiplayer/PlayerControllerMP.clickBlock(Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/util/EnumFacing;)Z" + ) + ) + private void clickMouse(CallbackInfo ci, BlockPos pos) { + Baritone.INSTANCE.getGameEventHandler().onBlockInteract(new BlockInteractEvent(pos, BlockInteractEvent.Type.BREAK)); + } + + @Inject( + method = "rightClickMouse", + at = @At( + value = "INVOKE", + target = "net/minecraft/client/entity/EntityPlayerSP.swingArm(Lnet/minecraft/util/EnumHand;)V" + ), + locals = LocalCapture.CAPTURE_FAILHARD + ) + private void onBlockInteract(CallbackInfo ci, EnumHand var1[], int var2, int var3, EnumHand enumhand, ItemStack itemstack, BlockPos blockpos, int i, EnumActionResult enumactionresult) { + Baritone.INSTANCE.getGameEventHandler().onBlockInteract(new BlockInteractEvent(blockpos, BlockInteractEvent.Type.USE)); + } } From 5760d0fb8df3563556021ace9d2354e672a3921b Mon Sep 17 00:00:00 2001 From: Brady Date: Wed, 22 Aug 2018 21:05:52 -0500 Subject: [PATCH 05/86] Fix MixinMinecraft#onBlockBreak local capture --- src/main/java/baritone/launch/mixins/MixinMinecraft.java | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/main/java/baritone/launch/mixins/MixinMinecraft.java b/src/main/java/baritone/launch/mixins/MixinMinecraft.java index 487f126f..f7bf4d36 100755 --- a/src/main/java/baritone/launch/mixins/MixinMinecraft.java +++ b/src/main/java/baritone/launch/mixins/MixinMinecraft.java @@ -167,9 +167,10 @@ public class MixinMinecraft { at = @At( value = "INVOKE", target = "net/minecraft/client/multiplayer/PlayerControllerMP.clickBlock(Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/util/EnumFacing;)Z" - ) + ), + locals = LocalCapture.CAPTURE_FAILHARD ) - private void clickMouse(CallbackInfo ci, BlockPos pos) { + private void onBlockBreak(CallbackInfo ci, BlockPos pos) { Baritone.INSTANCE.getGameEventHandler().onBlockInteract(new BlockInteractEvent(pos, BlockInteractEvent.Type.BREAK)); } @@ -181,7 +182,7 @@ public class MixinMinecraft { ), locals = LocalCapture.CAPTURE_FAILHARD ) - private void onBlockInteract(CallbackInfo ci, EnumHand var1[], int var2, int var3, EnumHand enumhand, ItemStack itemstack, BlockPos blockpos, int i, EnumActionResult enumactionresult) { + private void onBlockUse(CallbackInfo ci, EnumHand var1[], int var2, int var3, EnumHand enumhand, ItemStack itemstack, BlockPos blockpos, int i, EnumActionResult enumactionresult) { Baritone.INSTANCE.getGameEventHandler().onBlockInteract(new BlockInteractEvent(blockpos, BlockInteractEvent.Type.USE)); } } From 9dcadc979e65a3385081d40bbdf8c7097580ed88 Mon Sep 17 00:00:00 2001 From: Brady Date: Wed, 22 Aug 2018 21:26:45 -0500 Subject: [PATCH 06/86] Add death waypoints when the player dies, fixes #75 --- src/main/java/baritone/Baritone.java | 2 + .../impl/LocationTrackingBehavior.java | 57 +++++++++++++++++++ .../behavior/impl/MemoryBehavior.java | 12 ---- .../java/baritone/event/GameEventHandler.java | 5 ++ .../listener/AbstractGameEventListener.java | 3 + .../event/listener/IGameEventListener.java | 9 +++ .../launch/mixins/MixinGuiGameOver.java | 37 ++++++++++++ src/main/resources/mixins.baritone.json | 1 + 8 files changed, 114 insertions(+), 12 deletions(-) create mode 100644 src/main/java/baritone/behavior/impl/LocationTrackingBehavior.java create mode 100644 src/main/java/baritone/launch/mixins/MixinGuiGameOver.java diff --git a/src/main/java/baritone/Baritone.java b/src/main/java/baritone/Baritone.java index 8a8720ce..5642323b 100755 --- a/src/main/java/baritone/Baritone.java +++ b/src/main/java/baritone/Baritone.java @@ -21,6 +21,7 @@ import baritone.behavior.Behavior; import baritone.behavior.impl.LookBehavior; import baritone.behavior.impl.MemoryBehavior; import baritone.behavior.impl.PathingBehavior; +import baritone.behavior.impl.LocationTrackingBehavior; import baritone.event.GameEventHandler; import baritone.utils.InputOverrideHandler; import net.minecraft.client.Minecraft; @@ -70,6 +71,7 @@ public enum Baritone { registerBehavior(PathingBehavior.INSTANCE); registerBehavior(LookBehavior.INSTANCE); registerBehavior(MemoryBehavior.INSTANCE); + registerBehavior(LocationTrackingBehavior.INSTANCE); } this.dir = new File(Minecraft.getMinecraft().gameDir, "baritone"); if (!Files.exists(dir.toPath())) { diff --git a/src/main/java/baritone/behavior/impl/LocationTrackingBehavior.java b/src/main/java/baritone/behavior/impl/LocationTrackingBehavior.java new file mode 100644 index 00000000..8498690e --- /dev/null +++ b/src/main/java/baritone/behavior/impl/LocationTrackingBehavior.java @@ -0,0 +1,57 @@ +/* + * This file is part of Baritone. + * + * Baritone is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Baritone. If not, see . + */ + +package baritone.behavior.impl; + +import baritone.behavior.Behavior; +import baritone.chunk.Waypoint; +import baritone.chunk.WorldProvider; +import baritone.event.events.BlockInteractEvent; +import baritone.utils.BlockStateInterface; +import net.minecraft.block.BlockBed; + +/** + * A collection of event methods that are used to interact with Baritone's + * waypoint system. This class probably needs a better name. + * + * @see Waypoint + * + * @author Brady + * @since 8/22/2018 + */ +public final class LocationTrackingBehavior extends Behavior { + + public static final LocationTrackingBehavior INSTANCE = new LocationTrackingBehavior(); + + private LocationTrackingBehavior() {} + + @Override + public void onBlockInteract(BlockInteractEvent event) { + if (event.getType() == BlockInteractEvent.Type.USE && BlockStateInterface.get(event.getPos()) instanceof BlockBed) { + createWaypointAtPlayer("bed", Waypoint.Tag.BED); + } + } + + @Override + public void onPlayerDeath() { + createWaypointAtPlayer("death", Waypoint.Tag.DEATH); + } + + private void createWaypointAtPlayer(String name, Waypoint.Tag tag) { + WorldProvider.INSTANCE.getCurrentWorld().waypoints.addWaypoint(new Waypoint(name, tag, playerFeet())); + } +} diff --git a/src/main/java/baritone/behavior/impl/MemoryBehavior.java b/src/main/java/baritone/behavior/impl/MemoryBehavior.java index f8009c43..ed5bd686 100644 --- a/src/main/java/baritone/behavior/impl/MemoryBehavior.java +++ b/src/main/java/baritone/behavior/impl/MemoryBehavior.java @@ -1,14 +1,9 @@ package baritone.behavior.impl; import baritone.behavior.Behavior; -import baritone.chunk.Waypoint; -import baritone.chunk.WorldProvider; -import baritone.event.events.BlockInteractEvent; import baritone.event.events.PacketEvent; import baritone.event.events.PlayerUpdateEvent; import baritone.event.events.type.EventState; -import baritone.utils.BlockStateInterface; -import net.minecraft.block.BlockBed; import net.minecraft.item.ItemStack; import net.minecraft.network.Packet; import net.minecraft.network.play.client.CPacketCloseWindow; @@ -109,13 +104,6 @@ public class MemoryBehavior extends Behavior { } } - @Override - public void onBlockInteract(BlockInteractEvent event) { - if (event.getType() == BlockInteractEvent.Type.USE && BlockStateInterface.get(event.getPos()) instanceof BlockBed) { - WorldProvider.INSTANCE.getCurrentWorld().waypoints.addWaypoint(new Waypoint("bed", Waypoint.Tag.BED, playerFeet())); - } - } - private Optional getInventoryFromWindow(int windowId) { return this.rememberedInventories.values().stream().filter(i -> i.windowId == windowId).findFirst(); } diff --git a/src/main/java/baritone/event/GameEventHandler.java b/src/main/java/baritone/event/GameEventHandler.java index c61201bf..bfc42219 100644 --- a/src/main/java/baritone/event/GameEventHandler.java +++ b/src/main/java/baritone/event/GameEventHandler.java @@ -179,6 +179,11 @@ public final class GameEventHandler implements IGameEventListener, Helper { dispatch(listener -> listener.onBlockInteract(event)); } + @Override + public void onPlayerDeath() { + dispatch(IGameEventListener::onPlayerDeath); + } + public final void registerEventListener(IGameEventListener listener) { this.listeners.add(listener); } diff --git a/src/main/java/baritone/event/listener/AbstractGameEventListener.java b/src/main/java/baritone/event/listener/AbstractGameEventListener.java index 4f940c38..0f113119 100644 --- a/src/main/java/baritone/event/listener/AbstractGameEventListener.java +++ b/src/main/java/baritone/event/listener/AbstractGameEventListener.java @@ -83,4 +83,7 @@ public interface AbstractGameEventListener extends IGameEventListener { @Override default void onBlockInteract(BlockInteractEvent event) {} + + @Override + default void onPlayerDeath() {} } diff --git a/src/main/java/baritone/event/listener/IGameEventListener.java b/src/main/java/baritone/event/listener/IGameEventListener.java index 1958f0c3..bb52a66d 100644 --- a/src/main/java/baritone/event/listener/IGameEventListener.java +++ b/src/main/java/baritone/event/listener/IGameEventListener.java @@ -39,6 +39,7 @@ import io.netty.util.concurrent.GenericFutureListener; import net.minecraft.block.state.IBlockState; import net.minecraft.client.Minecraft; import net.minecraft.client.entity.EntityPlayerSP; +import net.minecraft.client.gui.GuiGameOver; import net.minecraft.client.multiplayer.WorldClient; import net.minecraft.client.renderer.EntityRenderer; import net.minecraft.client.settings.GameSettings; @@ -46,6 +47,7 @@ import net.minecraft.entity.Entity; import net.minecraft.entity.player.InventoryPlayer; import net.minecraft.network.NetworkManager; import net.minecraft.network.Packet; +import net.minecraft.util.text.ITextComponent; /** * @author Brady @@ -140,4 +142,11 @@ public interface IGameEventListener { * @see Minecraft#rightClickMouse() */ void onBlockInteract(BlockInteractEvent event); + + /** + * Called when the local player dies, as indicated by the creation of the {@link GuiGameOver} screen. + * + * @see GuiGameOver(ITextComponent) + */ + void onPlayerDeath(); } diff --git a/src/main/java/baritone/launch/mixins/MixinGuiGameOver.java b/src/main/java/baritone/launch/mixins/MixinGuiGameOver.java new file mode 100644 index 00000000..1579d529 --- /dev/null +++ b/src/main/java/baritone/launch/mixins/MixinGuiGameOver.java @@ -0,0 +1,37 @@ +/* + * This file is part of Baritone. + * + * Baritone is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Baritone. If not, see . + */ + +package baritone.launch.mixins; + +import baritone.Baritone; +import net.minecraft.client.gui.GuiGameOver; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; + +/** + * @author Brady + * @since 8/22/2018 + */ +@Mixin(GuiGameOver.class) +public class MixinGuiGameOver { + + @Inject(method = "", at = @At("RETURN")) + private void onInit() { + Baritone.INSTANCE.getGameEventHandler().onPlayerDeath(); + } +} diff --git a/src/main/resources/mixins.baritone.json b/src/main/resources/mixins.baritone.json index 025d42f8..e05bca84 100755 --- a/src/main/resources/mixins.baritone.json +++ b/src/main/resources/mixins.baritone.json @@ -13,6 +13,7 @@ "MixinEntityRenderer", "MixinGameSettings", "MixinGuiContainer", + "MixinGuiGameOver", "MixinGuiScreen", "MixinInventoryPlayer", "MixinKeyBinding", From 6a5bdf9023700525ec8b8eedc498ee61196bdc98 Mon Sep 17 00:00:00 2001 From: Brady Date: Wed, 22 Aug 2018 21:33:56 -0500 Subject: [PATCH 07/86] Cache the block break time in ToolSet, fixes #80 --- src/main/java/baritone/utils/ToolSet.java | 24 ++++++++++++++++++++--- 1 file changed, 21 insertions(+), 3 deletions(-) diff --git a/src/main/java/baritone/utils/ToolSet.java b/src/main/java/baritone/utils/ToolSet.java index f5f14c8f..bb445226 100644 --- a/src/main/java/baritone/utils/ToolSet.java +++ b/src/main/java/baritone/utils/ToolSet.java @@ -69,7 +69,13 @@ public class ToolSet implements Helper { * The values in this map are *not* hotbar slots indexes, they need to be looked up in slots * in order to be converted into hotbar slots. */ - private Map cache = new HashMap<>(); + private Map slotCache = new HashMap<>(); + + /** + * A cache mapping a {@link IBlockState} to how long it will take to break + * with this toolset, given the optimum tool is used. + */ + private Map breakStrengthCache = new HashMap<>(); /** * Create a toolset from the current player's inventory (but don't calculate any hardness values just yet) @@ -96,7 +102,7 @@ public class ToolSet implements Helper { * @return get which tool on the hotbar is best for mining it */ public Item getBestTool(IBlockState state) { - return tools.get(cache.computeIfAbsent(state.getBlock(), block -> getBestToolIndex(state))); + return tools.get(slotCache.computeIfAbsent(state.getBlock(), block -> getBestToolIndex(state))); } /** @@ -129,7 +135,7 @@ public class ToolSet implements Helper { * @return a byte indicating which hotbar slot worked best */ public byte getBestSlot(IBlockState state) { - return slots.get(cache.computeIfAbsent(state.getBlock(), block -> getBestToolIndex(state))); + return slots.get(slotCache.computeIfAbsent(state.getBlock(), block -> getBestToolIndex(state))); } /** @@ -140,6 +146,18 @@ public class ToolSet implements Helper { * @return how long it would take in ticks */ public double getStrVsBlock(IBlockState state, BlockPos pos) { + return this.breakStrengthCache.computeIfAbsent(state, s -> calculateStrVsBlock(s, pos)); + } + + /** + * Calculates how long would it take to mine the specified block given the best tool + * in this toolset is used. + * + * @param state the blockstate to be mined + * @param pos the blockpos to be mined + * @return how long it would take in ticks + */ + private double calculateStrVsBlock(IBlockState state, BlockPos pos) { // Calculate the slot with the best item byte slot = this.getBestSlot(state); From dbb5d56b74a537710d16a558cd96b27bfc416573 Mon Sep 17 00:00:00 2001 From: Brady Date: Wed, 22 Aug 2018 21:45:45 -0500 Subject: [PATCH 08/86] Fix MixinGuiGameOver init Injection parameters --- src/main/java/baritone/launch/mixins/MixinGuiGameOver.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/main/java/baritone/launch/mixins/MixinGuiGameOver.java b/src/main/java/baritone/launch/mixins/MixinGuiGameOver.java index 1579d529..36ded3a2 100644 --- a/src/main/java/baritone/launch/mixins/MixinGuiGameOver.java +++ b/src/main/java/baritone/launch/mixins/MixinGuiGameOver.java @@ -19,9 +19,11 @@ package baritone.launch.mixins; import baritone.Baritone; import net.minecraft.client.gui.GuiGameOver; +import net.minecraft.util.text.ITextComponent; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.injection.At; import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; /** * @author Brady @@ -31,7 +33,7 @@ import org.spongepowered.asm.mixin.injection.Inject; public class MixinGuiGameOver { @Inject(method = "", at = @At("RETURN")) - private void onInit() { + private void onInit(ITextComponent causeOfDeathIn, CallbackInfo ci) { Baritone.INSTANCE.getGameEventHandler().onPlayerDeath(); } } From 2d7b46584452b3cb776f8c75824470275af0f08d Mon Sep 17 00:00:00 2001 From: Brady Date: Wed, 22 Aug 2018 22:07:27 -0500 Subject: [PATCH 09/86] Added an anti-cheat compatibility setting, to tie in with free look --- src/main/java/baritone/Settings.java | 8 ++++ .../baritone/behavior/impl/LookBehavior.java | 44 ++++++++++++++----- 2 files changed, 42 insertions(+), 10 deletions(-) diff --git a/src/main/java/baritone/Settings.java b/src/main/java/baritone/Settings.java index 207703cb..f1ac0474 100644 --- a/src/main/java/baritone/Settings.java +++ b/src/main/java/baritone/Settings.java @@ -222,6 +222,14 @@ public class Settings { */ public Setting freeLook = new Setting<>(true); + /** + * Will cause some minor behavioral differences to ensure that Baritone works on anticheats. + *

+ * At the moment this will silently set the player's rotations when using freeLook so you're not sprinting in + * directions other than forward, which is picken up by more "advanced" anticheats like AAC, but not NCP. + */ + public Setting antiCheatCompatibility = new Setting<>(true); + /** * Exclusively use cached chunks for pathing */ diff --git a/src/main/java/baritone/behavior/impl/LookBehavior.java b/src/main/java/baritone/behavior/impl/LookBehavior.java index a531cd88..00ffce54 100644 --- a/src/main/java/baritone/behavior/impl/LookBehavior.java +++ b/src/main/java/baritone/behavior/impl/LookBehavior.java @@ -58,21 +58,42 @@ public class LookBehavior extends Behavior { @Override public void onPlayerUpdate(PlayerUpdateEvent event) { - if (event.getState() == EventState.PRE && this.target != null && this.force) { - player().rotationYaw = this.target.getFirst(); - float oldPitch = player().rotationPitch; - float desiredPitch = this.target.getSecond(); - player().rotationPitch = desiredPitch; - if (desiredPitch == oldPitch) { - nudgeToLevel(); + if (this.target == null) + return; + + // Whether or not we're going to silently set our angles + boolean silent = Baritone.settings().antiCheatCompatibility.get(); + + switch (event.getState()) { + case PRE: { + if (this.force) { + player().rotationYaw = this.target.getFirst(); + float oldPitch = player().rotationPitch; + float desiredPitch = this.target.getSecond(); + player().rotationPitch = desiredPitch; + if (desiredPitch == oldPitch) { + nudgeToLevel(); + } + this.target = null; + } else if (silent) { + this.lastYaw = player().rotationYaw; + player().rotationYaw = this.target.getFirst(); + } + break; + } + case POST: { + if (!this.force && silent) { + player().rotationYaw = this.lastYaw; + this.target = null; + } + break; } - this.target = null; } } @Override public void onPlayerRelativeMove(RelativeMoveEvent event) { - if (this.target != null && !force) { + if (this.target != null && !this.force) { switch (event.getState()) { case PRE: this.lastYaw = player().rotationYaw; @@ -80,7 +101,10 @@ public class LookBehavior extends Behavior { break; case POST: player().rotationYaw = this.lastYaw; - this.target = null; + + // If we have antiCheatCompatibility on, we're going to use the target value later in onPlayerUpdate() + if (!Baritone.settings().antiCheatCompatibility.get()) + this.target = null; break; } } From 5baa56bb29245a4b52a4794f59bc84dc95c15524 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Thu, 23 Aug 2018 08:52:05 -0700 Subject: [PATCH 10/86] add option for pythagorean metric --- src/main/java/baritone/Settings.java | 5 +++++ src/main/java/baritone/pathing/goals/GoalXZ.java | 3 +++ 2 files changed, 8 insertions(+) diff --git a/src/main/java/baritone/Settings.java b/src/main/java/baritone/Settings.java index f1ac0474..c689d05a 100644 --- a/src/main/java/baritone/Settings.java +++ b/src/main/java/baritone/Settings.java @@ -107,6 +107,11 @@ public class Settings { */ public Setting minimumImprovementRepropagation = new Setting<>(true); + /** + * Use a pythagorean metric (as opposed to the more accurate hybrid diagonal / traverse). + */ + public Setting pythagoreanMetric = new Setting<>(false); + /** * After calculating a path (potentially through cached chunks), artificially cut it off to just the part that is * entirely within currently loaded chunks. Improves path safety because cached chunks are heavily simplified. diff --git a/src/main/java/baritone/pathing/goals/GoalXZ.java b/src/main/java/baritone/pathing/goals/GoalXZ.java index d8153b00..de48da83 100644 --- a/src/main/java/baritone/pathing/goals/GoalXZ.java +++ b/src/main/java/baritone/pathing/goals/GoalXZ.java @@ -64,6 +64,9 @@ public class GoalXZ implements Goal { } public static double calculate(double xDiff, double zDiff) { + if (Baritone.settings().pythagoreanMetric.get()) { + return Math.sqrt(xDiff * xDiff + zDiff * zDiff) * Baritone.settings().costHeuristic.get(); + } //This is a combination of pythagorean and manhattan distance //It takes into account the fact that pathing can either walk diagonally or forwards From f9189d7ec33f5e692e7e4bcfa26092f9d6ddeb65 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Thu, 23 Aug 2018 09:07:43 -0700 Subject: [PATCH 11/86] comment --- src/main/java/baritone/Settings.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/main/java/baritone/Settings.java b/src/main/java/baritone/Settings.java index c689d05a..57e0543b 100644 --- a/src/main/java/baritone/Settings.java +++ b/src/main/java/baritone/Settings.java @@ -109,6 +109,7 @@ public class Settings { /** * Use a pythagorean metric (as opposed to the more accurate hybrid diagonal / traverse). + * You probably don't want this. It roughly triples nodes considered for no real advantage. */ public Setting pythagoreanMetric = new Setting<>(false); From bde507cac6c4521ca57bd9a11057cec327784040 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Thu, 23 Aug 2018 09:41:17 -0700 Subject: [PATCH 12/86] clear blocks in the way, probably fixes #82 --- .../baritone/pathing/movement/movements/MovementTraverse.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java index 105c1997..ad9a129f 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java @@ -196,10 +196,12 @@ public class MovementTraverse extends Movement { if (Objects.equals(LookBehaviorUtils.getSelectedBlock().orElse(null), against1) && Minecraft.getMinecraft().player.isSneaking()) { if (LookBehaviorUtils.getSelectedBlock().get().offset(side).equals(positionsToPlace[0])) { state.setInput(InputOverrideHandler.Input.CLICK_RIGHT, true); + return state; } else { // Out.gui("Wrong. " + side + " " + LookBehaviorUtils.getSelectedBlock().get().offset(side) + " " + positionsToPlace[0], Out.Mode.Debug); } } + state.setInput(InputOverrideHandler.Input.CLICK_LEFT, true); System.out.println("Trying to look at " + against1 + ", actually looking at" + LookBehaviorUtils.getSelectedBlock()); return state; } From 3ce764a472c97876ff0a9fb717c354526402dc49 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Thu, 23 Aug 2018 09:54:29 -0700 Subject: [PATCH 13/86] waypoint convenience methods --- src/main/java/baritone/chunk/Waypoint.java | 26 ++++++++-- .../utils/ExampleBaritoneControl.java | 52 +++++++++++++++++-- 2 files changed, 69 insertions(+), 9 deletions(-) diff --git a/src/main/java/baritone/chunk/Waypoint.java b/src/main/java/baritone/chunk/Waypoint.java index d834ee2c..cb2adbc8 100644 --- a/src/main/java/baritone/chunk/Waypoint.java +++ b/src/main/java/baritone/chunk/Waypoint.java @@ -19,6 +19,8 @@ package baritone.chunk; import net.minecraft.util.math.BlockPos; +import java.util.Collections; +import java.util.Date; import java.util.HashMap; import java.util.Map; @@ -61,14 +63,28 @@ public class Waypoint { return name.hashCode() + tag.hashCode() + (int) creationTimestamp + location.hashCode(); //lol } + public long creationTimestamp() { + return creationTimestamp; + } + + public String toString() { + return name + " " + location.toString() + " " + new Date(creationTimestamp).toString(); + } + public enum Tag { HOME, DEATH, BED, USER; - { - map.put(name().toLowerCase(), this); - } - } - private static final Map map = new HashMap<>(); + public static final Map TAG_MAP; + + static { + HashMap map = new HashMap<>(); + map.put("home", Tag.HOME); + map.put("base", Tag.HOME); + map.put("bed", Tag.BED); + map.put("spawn", Tag.BED); + map.put("death", Tag.DEATH); + TAG_MAP = Collections.unmodifiableMap(map); + } } diff --git a/src/main/java/baritone/utils/ExampleBaritoneControl.java b/src/main/java/baritone/utils/ExampleBaritoneControl.java index fae6a4d8..7d62fdaa 100644 --- a/src/main/java/baritone/utils/ExampleBaritoneControl.java +++ b/src/main/java/baritone/utils/ExampleBaritoneControl.java @@ -35,10 +35,7 @@ import baritone.pathing.movement.Movement; import baritone.utils.pathing.BetterBlockPos; import net.minecraft.util.math.BlockPos; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Comparator; -import java.util.List; +import java.util.*; public class ExampleBaritoneControl extends Behavior { public static ExampleBaritoneControl INSTANCE = new ExampleBaritoneControl(); @@ -115,6 +112,53 @@ public class ExampleBaritoneControl extends Behavior { event.cancel(); return; } + if (msg.toLowerCase().startsWith("list") || msg.toLowerCase().startsWith("get ") || msg.toLowerCase().startsWith("show")) { + String waypointType = msg.toLowerCase().substring(4).trim(); + if (waypointType.endsWith("s")) { + // for example, "show deaths" + waypointType = waypointType.substring(0, waypointType.length() - 1); + } + Waypoint.Tag tag = Waypoint.TAG_MAP.get(waypointType); + if (tag == null) { + displayChatMessageRaw("Not a valid tag. Tags are: " + Arrays.asList(Waypoint.Tag.values()).toString().toLowerCase()); + event.cancel(); + return; + } + Set waypoints = WorldProvider.INSTANCE.getCurrentWorld().waypoints.getByTag(tag); + // might as well show them from oldest to newest + List sorted = new ArrayList<>(waypoints); + sorted.sort(Comparator.comparingLong(Waypoint::creationTimestamp).reversed()); + displayChatMessageRaw("Waypoints under tag " + tag + ":"); + for (Waypoint waypoint : sorted) { + displayChatMessageRaw(waypoint.toString()); + } + event.cancel(); + return; + } + if (msg.toLowerCase().startsWith("goto")) { + String waypointType = msg.toLowerCase().substring(4).trim(); + if (waypointType.endsWith("s")) { + // for example, "show deaths" + waypointType = waypointType.substring(0, waypointType.length() - 1); + } + Waypoint.Tag tag = Waypoint.TAG_MAP.get(waypointType); + if (tag == null) { + displayChatMessageRaw("Not a valid tag. Tags are: " + Arrays.asList(Waypoint.Tag.values()).toString().toLowerCase()); + event.cancel(); + return; + } + Waypoint waypoint = WorldProvider.INSTANCE.getCurrentWorld().waypoints.getMostRecentByTag(tag); + if (waypoint == null) { + displayChatMessageRaw("None saved for tag " + tag); + event.cancel(); + return; + } + Goal goal = new GoalBlock(waypoint.location); + PathingBehavior.INSTANCE.setGoal(goal); + PathingBehavior.INSTANCE.path(); + event.cancel(); + return; + } if (msg.toLowerCase().equals("spawn") || msg.toLowerCase().equals("bed")) { Waypoint waypoint = WorldProvider.INSTANCE.getCurrentWorld().waypoints.getMostRecentByTag(Waypoint.Tag.BED); if (waypoint == null) { From a7abfef32946728f0a0caa8f8aec3ca090e38ea5 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Thu, 23 Aug 2018 09:56:57 -0700 Subject: [PATCH 14/86] whoops wrong order --- src/main/java/baritone/utils/ExampleBaritoneControl.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/baritone/utils/ExampleBaritoneControl.java b/src/main/java/baritone/utils/ExampleBaritoneControl.java index 7d62fdaa..d1fc14ee 100644 --- a/src/main/java/baritone/utils/ExampleBaritoneControl.java +++ b/src/main/java/baritone/utils/ExampleBaritoneControl.java @@ -127,7 +127,7 @@ public class ExampleBaritoneControl extends Behavior { Set waypoints = WorldProvider.INSTANCE.getCurrentWorld().waypoints.getByTag(tag); // might as well show them from oldest to newest List sorted = new ArrayList<>(waypoints); - sorted.sort(Comparator.comparingLong(Waypoint::creationTimestamp).reversed()); + sorted.sort(Comparator.comparingLong(Waypoint::creationTimestamp)); displayChatMessageRaw("Waypoints under tag " + tag + ":"); for (Waypoint waypoint : sorted) { displayChatMessageRaw(waypoint.toString()); From 36cbffb59392a61a3e93cc003c80c8323abe87b1 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Thu, 23 Aug 2018 11:14:37 -0700 Subject: [PATCH 15/86] reset, fixes #84 --- src/main/java/baritone/pathing/movement/Movement.java | 3 +++ .../baritone/pathing/movement/movements/MovementAscend.java | 6 ++++++ .../pathing/movement/movements/MovementDescend.java | 6 ++++++ .../pathing/movement/movements/MovementDownward.java | 6 ++++++ .../baritone/pathing/movement/movements/MovementPillar.java | 6 ++++++ .../pathing/movement/movements/MovementTraverse.java | 6 ++++++ src/main/java/baritone/pathing/path/PathExecutor.java | 4 ++++ 7 files changed, 37 insertions(+) diff --git a/src/main/java/baritone/pathing/movement/Movement.java b/src/main/java/baritone/pathing/movement/Movement.java index e461d701..99c17d8c 100644 --- a/src/main/java/baritone/pathing/movement/Movement.java +++ b/src/main/java/baritone/pathing/movement/Movement.java @@ -187,6 +187,9 @@ public abstract class Movement implements Helper, MovementHelper { currentState.setStatus(MovementStatus.CANCELED); } + public void reset() { + currentState = new MovementState().setStatus(MovementStatus.PREPPING); + } public double getTotalHardnessOfBlocksToBreak(CalculationContext ctx) { /* diff --git a/src/main/java/baritone/pathing/movement/movements/MovementAscend.java b/src/main/java/baritone/pathing/movement/movements/MovementAscend.java index e7ecce25..596a6d86 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementAscend.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementAscend.java @@ -64,6 +64,12 @@ public class MovementAscend extends Movement { // Counterpoint to the above TODO ^ you should move then pillar instead of ascend } + @Override + public void reset() { + super.reset(); + ticksWithoutPlacement = 0; + } + @Override protected double calculateCost(CalculationContext context) { IBlockState toPlace = BlockStateInterface.get(positionsToPlace[0]); diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDescend.java b/src/main/java/baritone/pathing/movement/movements/MovementDescend.java index 97c55f63..dab57257 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementDescend.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementDescend.java @@ -36,6 +36,12 @@ public class MovementDescend extends Movement { super(start, end, new BlockPos[]{end.up(2), end.up(), end}, new BlockPos[]{end.down()}); } + @Override + public void reset() { + super.reset(); + numTicks = 0; + } + @Override protected double calculateCost(CalculationContext context) { if (!MovementHelper.canWalkOn(positionsToPlace[0])) { diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDownward.java b/src/main/java/baritone/pathing/movement/movements/MovementDownward.java index 2490fdd1..285053c2 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementDownward.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementDownward.java @@ -36,6 +36,12 @@ public class MovementDownward extends Movement { super(start, end, new BlockPos[]{end}, new BlockPos[0]); } + @Override + public void reset() { + super.reset(); + numTicks = 0; + } + @Override protected double calculateCost(CalculationContext context) { if (!MovementHelper.canWalkOn(dest.down())) { diff --git a/src/main/java/baritone/pathing/movement/movements/MovementPillar.java b/src/main/java/baritone/pathing/movement/movements/MovementPillar.java index 890637b0..5dcef948 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementPillar.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementPillar.java @@ -38,6 +38,12 @@ public class MovementPillar extends Movement { super(start, end, new BlockPos[]{start.up(2)}, new BlockPos[]{start}); } + @Override + public void reset() { + super.reset(); + numTicks = 0; + } + @Override protected double calculateCost(CalculationContext context) { Block fromDown = BlockStateInterface.get(src).getBlock(); diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java index ad9a129f..51429db4 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java @@ -66,6 +66,12 @@ public class MovementTraverse extends Movement { //note: do NOT add ability to place against .down().down() } + @Override + public void reset() { + super.reset(); + wasTheBridgeBlockAlwaysThere = true; + } + @Override protected double calculateCost(CalculationContext context) { IBlockState pb0 = BlockStateInterface.get(positionsToBreak[0]); diff --git a/src/main/java/baritone/pathing/path/PathExecutor.java b/src/main/java/baritone/pathing/path/PathExecutor.java index dee3458a..88a7126c 100644 --- a/src/main/java/baritone/pathing/path/PathExecutor.java +++ b/src/main/java/baritone/pathing/path/PathExecutor.java @@ -90,7 +90,11 @@ public class PathExecutor implements Helper { for (int i = 0; i < pathPosition - 2 && i < path.length(); i++) {//this happens for example when you lag out and get teleported back a couple blocks if (whereAmI.equals(path.positions().get(i))) { displayChatMessageRaw("Skipping back " + (pathPosition - i) + " steps, to " + i); + int previousPos = pathPosition; pathPosition = Math.max(i - 1, 0); // previous step might not actually be done + for (int j = pathPosition; j <= previousPos; j++) { + path.movements().get(j).reset(); + } Baritone.INSTANCE.getInputOverrideHandler().clearAllKeys(); return false; } From 8dd064838b333b51092c828170e6c24125cbe49b Mon Sep 17 00:00:00 2001 From: Brady Date: Thu, 23 Aug 2018 14:52:35 -0500 Subject: [PATCH 16/86] Utilize streams when finding most recent waypoint of a given tag --- src/main/java/baritone/chunk/Waypoint.java | 2 +- src/main/java/baritone/chunk/Waypoints.java | 14 ++++---------- 2 files changed, 5 insertions(+), 11 deletions(-) diff --git a/src/main/java/baritone/chunk/Waypoint.java b/src/main/java/baritone/chunk/Waypoint.java index cb2adbc8..aa800907 100644 --- a/src/main/java/baritone/chunk/Waypoint.java +++ b/src/main/java/baritone/chunk/Waypoint.java @@ -32,7 +32,7 @@ import java.util.Map; public class Waypoint { public final String name; public final Tag tag; - public final long creationTimestamp; + private final long creationTimestamp; public final BlockPos location; public Waypoint(String name, Tag tag, BlockPos location) { diff --git a/src/main/java/baritone/chunk/Waypoints.java b/src/main/java/baritone/chunk/Waypoints.java index 2ad7f16d..fafc102b 100644 --- a/src/main/java/baritone/chunk/Waypoints.java +++ b/src/main/java/baritone/chunk/Waypoints.java @@ -79,11 +79,11 @@ public class Waypoints { try ( FileOutputStream fileOut = new FileOutputStream(fileName.toFile()); BufferedOutputStream bufOut = new BufferedOutputStream(fileOut); - DataOutputStream out = new DataOutputStream(bufOut); + DataOutputStream out = new DataOutputStream(bufOut) ) { for (Waypoint waypoint : waypoints.get(tag)) { out.writeUTF(waypoint.name); - out.writeLong(waypoint.creationTimestamp); + out.writeLong(waypoint.creationTimestamp()); out.writeInt(waypoint.location.getX()); out.writeInt(waypoint.location.getY()); out.writeInt(waypoint.location.getZ()); @@ -98,14 +98,8 @@ public class Waypoints { } public Waypoint getMostRecentByTag(Waypoint.Tag tag) { - Set pts = waypoints.get(tag); - Waypoint best = null; - for (Waypoint waypoint : pts) { - if (best == null || waypoint.creationTimestamp > best.creationTimestamp) { - best = waypoint; - } - } - return best; + // Find a waypoint of the given tag which has the greatest timestamp value, indicating the most recent + return this.waypoints.get(tag).stream().min(Comparator.comparingLong(w -> -w.creationTimestamp())).orElse(null); } public void addWaypoint(Waypoint waypoint) { From d0fc77ede46e3c3b2d1affa046f7cf9c1933a9c3 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Thu, 23 Aug 2018 12:54:12 -0700 Subject: [PATCH 17/86] special block location caching and automatic mining --- src/main/java/baritone/chunk/CachedChunk.java | 56 +++++++++++++-- .../java/baritone/chunk/CachedRegion.java | 70 ++++++++++++++++++- src/main/java/baritone/chunk/CachedWorld.java | 27 +++++-- src/main/java/baritone/chunk/ChunkPacker.java | 48 ++++++++----- .../utils/ExampleBaritoneControl.java | 60 ++++++++++++++-- .../java/baritone/chunk/CachedRegionTest.java | 50 +++++++++++++ 6 files changed, 278 insertions(+), 33 deletions(-) create mode 100644 src/test/java/baritone/chunk/CachedRegionTest.java diff --git a/src/main/java/baritone/chunk/CachedChunk.java b/src/main/java/baritone/chunk/CachedChunk.java index f4d56fd2..fca8034d 100644 --- a/src/main/java/baritone/chunk/CachedChunk.java +++ b/src/main/java/baritone/chunk/CachedChunk.java @@ -21,8 +21,10 @@ import baritone.utils.pathing.IBlockTypeAccess; import baritone.utils.pathing.PathingBlockType; import net.minecraft.block.Block; import net.minecraft.block.state.IBlockState; +import net.minecraft.init.Blocks; +import net.minecraft.util.math.BlockPos; -import java.util.BitSet; +import java.util.*; /** * @author Brady @@ -30,6 +32,32 @@ import java.util.BitSet; */ public final class CachedChunk implements IBlockTypeAccess { + public static final Set BLOCKS_TO_KEEP_TRACK_OF = Collections.unmodifiableSet(new HashSet() {{ + add(Blocks.DIAMOND_ORE); + add(Blocks.DIAMOND_BLOCK); + //add(Blocks.COAL_ORE); + add(Blocks.COAL_BLOCK); + //add(Blocks.IRON_ORE); + add(Blocks.IRON_BLOCK); + //add(Blocks.GOLD_ORE); + add(Blocks.GOLD_BLOCK); + add(Blocks.EMERALD_ORE); + add(Blocks.EMERALD_BLOCK); + + add(Blocks.ENDER_CHEST); + add(Blocks.FURNACE); + add(Blocks.CHEST); + add(Blocks.END_PORTAL); + add(Blocks.END_PORTAL_FRAME); + add(Blocks.MOB_SPAWNER); + // TODO add all shulker colors + add(Blocks.PORTAL); + add(Blocks.HOPPER); + add(Blocks.BEACON); + add(Blocks.BREWING_STAND); + add(Blocks.SKULL); + }}); + /** * The size of the chunk data in bits. Equal to 16 KiB. *

@@ -66,7 +94,9 @@ public final class CachedChunk implements IBlockTypeAccess { private final int[] heightMap; - CachedChunk(int x, int z, BitSet data, String[] overview) { + private final Map> specialBlockLocations; + + CachedChunk(int x, int z, BitSet data, String[] overview, Map> specialBlockLocations) { validateSize(data); this.x = x; @@ -74,6 +104,7 @@ public final class CachedChunk implements IBlockTypeAccess { this.data = data; this.overview = overview; this.heightMap = new int[256]; + this.specialBlockLocations = specialBlockLocations; calculateHeightMap(); } @@ -82,11 +113,7 @@ public final class CachedChunk implements IBlockTypeAccess { int internalPos = z << 4 | x; if (heightMap[internalPos] == y) { // we have this exact block, it's a surface block - String name = overview[internalPos]; - if (!name.contains(":")) { - name = "minecraft:" + name; - } - IBlockState state = Block.getBlockFromName(name).getDefaultState(); + IBlockState state = ChunkPacker.stringToBlock(overview[internalPos]).getDefaultState(); //System.out.println("Saying that " + x + "," + y + "," + z + " is " + state); return state; } @@ -118,6 +145,21 @@ public final class CachedChunk implements IBlockTypeAccess { return overview; } + public final Map> getRelativeBlocks() { + return specialBlockLocations; + } + + public final LinkedList getAbsoluteBlocks(String blockType) { + if (specialBlockLocations.get(blockType) == null) { + return null; + } + LinkedList res = new LinkedList<>(); + for (BlockPos pos : specialBlockLocations.get(blockType)) { + res.add(new BlockPos(pos.getX() + x * 16, pos.getY(), pos.getZ() + z * 16)); + } + return res; + } + /** * @return Returns the raw packed chunk data as a byte array */ diff --git a/src/main/java/baritone/chunk/CachedRegion.java b/src/main/java/baritone/chunk/CachedRegion.java index d8996fa3..b9e0e4e0 100644 --- a/src/main/java/baritone/chunk/CachedRegion.java +++ b/src/main/java/baritone/chunk/CachedRegion.java @@ -19,12 +19,13 @@ package baritone.chunk; import baritone.utils.pathing.IBlockTypeAccess; import net.minecraft.block.state.IBlockState; +import net.minecraft.util.math.BlockPos; import java.io.*; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; -import java.util.BitSet; +import java.util.*; import java.util.function.Consumer; import java.util.zip.GZIPInputStream; import java.util.zip.GZIPOutputStream; @@ -77,6 +78,25 @@ public final class CachedRegion implements IBlockTypeAccess { return null; } + public final LinkedList getLocationsOf(String block) { + LinkedList res = new LinkedList<>(); + for (int chunkX = 0; chunkX < 32; chunkX++) { + for (int chunkZ = 0; chunkZ < 32; chunkZ++) { + if (chunks[chunkX][chunkZ] == null) { + continue; + } + List locs = chunks[chunkX][chunkZ].getAbsoluteBlocks(block); + if (locs == null) { + continue; + } + for (BlockPos pos : locs) { + res.add(pos); + } + } + } + return res; + } + final void updateCachedChunk(int chunkX, int chunkZ, CachedChunk chunk) { this.chunks[chunkX][chunkZ] = chunk; hasUnsavedChanges = true; @@ -139,6 +159,22 @@ public final class CachedRegion implements IBlockTypeAccess { } } } + for (int z = 0; z < 32; z++) { + for (int x = 0; x < 32; x++) { + if (chunks[x][z] != null) { + Map> locs = chunks[x][z].getRelativeBlocks(); + out.writeShort(locs.entrySet().size()); + for (Map.Entry> entry : locs.entrySet()) { + out.writeUTF(entry.getKey()); + out.writeShort(entry.getValue().size()); + for (BlockPos pos : entry.getValue()) { + out.writeByte((byte) (pos.getZ() << 4 | pos.getX())); + out.writeByte((byte) (pos.getY())); + } + } + } + } + } out.writeInt(~CACHED_REGION_MAGIC); } hasUnsavedChanges = false; @@ -174,6 +210,7 @@ public final class CachedRegion implements IBlockTypeAccess { throw new IOException("Bad magic value " + magic); } CachedChunk[][] tmpCached = new CachedChunk[32][32]; + Map>[][] location = new Map[32][32]; for (int z = 0; z < 32; z++) { for (int x = 0; x < 32; x++) { int isChunkPresent = in.read(); @@ -181,7 +218,12 @@ public final class CachedRegion implements IBlockTypeAccess { case CHUNK_PRESENT: byte[] bytes = new byte[CachedChunk.SIZE_IN_BYTES]; in.readFully(bytes); - tmpCached[x][z] = new CachedChunk(x, z, BitSet.valueOf(bytes), new String[256]); + location[x][z] = new HashMap<>(); + int regionX = this.x; + int regionZ = this.z; + int chunkX = x + 32 * regionX; + int chunkZ = z + 32 * regionZ; + tmpCached[x][z] = new CachedChunk(chunkX, chunkZ, BitSet.valueOf(bytes), new String[256], location[x][z]); break; case CHUNK_NOT_PRESENT: tmpCached[x][z] = null; @@ -200,6 +242,30 @@ public final class CachedRegion implements IBlockTypeAccess { } } } + for (int z = 0; z < 32; z++) { + for (int x = 0; x < 32; x++) { + if (tmpCached[x][z] != null) { + // 16 * 16 * 256 = 65536 so a short is enough + short numSpecialBlockTypes = in.readShort(); + for (int i = 0; i < numSpecialBlockTypes; i++) { + String blockName = in.readUTF(); + ArrayList locs = new ArrayList<>(); + location[x][z].put(blockName, locs); + short numLocations = in.readShort(); + for (int j = 0; j < numLocations; j++) { + byte xz = in.readByte(); + int X = xz & 0x0f; + int Z = (xz >>> 4) & 0x0f; + int Y = (int) in.readByte(); + if (Y < 0) { + Y += 256; + } + locs.add(new BlockPos(X, Y, Z)); + } + } + } + } + } int fileEndMagic = in.readInt(); if (fileEndMagic != ~magic) { throw new IOException("Bad end of file magic"); diff --git a/src/main/java/baritone/chunk/CachedWorld.java b/src/main/java/baritone/chunk/CachedWorld.java index 5374e837..3abcb8b3 100644 --- a/src/main/java/baritone/chunk/CachedWorld.java +++ b/src/main/java/baritone/chunk/CachedWorld.java @@ -21,12 +21,13 @@ import baritone.utils.pathing.IBlockTypeAccess; import it.unimi.dsi.fastutil.longs.Long2ObjectMap; import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap; import net.minecraft.block.state.IBlockState; +import net.minecraft.util.math.BlockPos; import net.minecraft.world.chunk.Chunk; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; -import java.util.BitSet; +import java.util.LinkedList; import java.util.concurrent.LinkedBlockingQueue; import java.util.function.Consumer; @@ -84,6 +85,16 @@ public final class CachedWorld implements IBlockTypeAccess { return region.getBlock(x & 511, y, z & 511); } + public final LinkedList getLocationsOf(String block) { + LinkedList res = new LinkedList<>(); + this.cachedRegions.values().forEach(region -> { + if (region != null) + for (BlockPos pos : region.getLocationsOf(block)) + res.add(pos); + }); + return res; + } + private void updateCachedChunk(CachedChunk chunk) { CachedRegion region = getOrCreateRegion(chunk.x >> 5, chunk.z >> 5); region.updateCachedChunk(chunk.x & 31, chunk.z & 31, chunk); @@ -99,6 +110,16 @@ public final class CachedWorld implements IBlockTypeAccess { System.out.println("World save took " + (now - start) + "ms"); } + public final void reloadAllFromDisk() { + long start = System.currentTimeMillis(); + this.cachedRegions.values().forEach(region -> { + if (region != null) + region.load(this.directory); + }); + long now = System.currentTimeMillis(); + System.out.println("World load took " + (now - start) + "ms"); + } + /** * Returns the region at the specified region coordinates * @@ -168,9 +189,7 @@ public final class CachedWorld implements IBlockTypeAccess { } try { Chunk chunk = queue.take(); - BitSet packedChunk = ChunkPacker.createPackedChunk(chunk); - String[] packedOverview = ChunkPacker.createPackedOverview(chunk); - CachedChunk cached = new CachedChunk(chunk.x, chunk.z, packedChunk, packedOverview); + CachedChunk cached = ChunkPacker.pack(chunk); CachedWorld.this.updateCachedChunk(cached); //System.out.println("Processed chunk at " + chunk.x + "," + chunk.z); } catch (InterruptedException e) { diff --git a/src/main/java/baritone/chunk/ChunkPacker.java b/src/main/java/baritone/chunk/ChunkPacker.java index c0688786..7cc569a7 100644 --- a/src/main/java/baritone/chunk/ChunkPacker.java +++ b/src/main/java/baritone/chunk/ChunkPacker.java @@ -28,9 +28,10 @@ import net.minecraft.block.BlockTallGrass; import net.minecraft.block.state.IBlockState; import net.minecraft.init.Blocks; import net.minecraft.util.ResourceLocation; +import net.minecraft.util.math.BlockPos; import net.minecraft.world.chunk.Chunk; -import java.util.BitSet; +import java.util.*; /** * @author Brady @@ -40,30 +41,33 @@ public final class ChunkPacker implements Helper { private ChunkPacker() {} - public static BitSet createPackedChunk(Chunk chunk) { + public static CachedChunk pack(Chunk chunk) { long start = System.currentTimeMillis(); + + Map> specialBlocks = new HashMap<>(); BitSet bitSet = new BitSet(CachedChunk.SIZE); try { for (int y = 0; y < 256; y++) { for (int z = 0; z < 16; z++) { for (int x = 0; x < 16; x++) { int index = CachedChunk.getPositionIndex(x, y, z); - boolean[] bits = getPathingBlockType(chunk.getBlockState(x, y, z).getBlock()).getBits(); + Block block = chunk.getBlockState(x, y, z).getBlock(); + boolean[] bits = getPathingBlockType(block).getBits(); bitSet.set(index, bits[0]); bitSet.set(index + 1, bits[1]); + if (CachedChunk.BLOCKS_TO_KEEP_TRACK_OF.contains(block)) { + String name = blockToString(block); + specialBlocks.computeIfAbsent(name, b -> new ArrayList<>()).add(new BlockPos(x, y, z)); + } } } } } catch (Exception e) { e.printStackTrace(); } + //System.out.println("Packed special blocks: " + specialBlocks); long end = System.currentTimeMillis(); //System.out.println("Chunk packing took " + (end - start) + "ms for " + chunk.x + "," + chunk.z); - return bitSet; - } - - public static String[] createPackedOverview(Chunk chunk) { - long start = System.currentTimeMillis(); String[] blockNames = new String[256]; for (int z = 0; z < 16; z++) { for (int x = 0; x < 16; x++) { @@ -75,17 +79,29 @@ public final class ChunkPacker implements Helper { break; } } - ResourceLocation loc = Block.REGISTRY.getNameForObject(blockState.getBlock()); - String name = loc.getPath(); // normally, only write the part after the minecraft: - if (!loc.getNamespace().equals("minecraft")) { - // Baritone is running on top of forge with mods installed, perhaps? - name = loc.toString(); // include the namespace with the colon - } + String name = blockToString(blockState.getBlock()); blockNames[z << 4 | x] = name; } } - long end = System.currentTimeMillis(); - return blockNames; + CachedChunk cached = new CachedChunk(chunk.x, chunk.z, bitSet, blockNames, specialBlocks); + return cached; + } + + public static String blockToString(Block block) { + ResourceLocation loc = Block.REGISTRY.getNameForObject(block); + String name = loc.getPath(); // normally, only write the part after the minecraft: + if (!loc.getNamespace().equals("minecraft")) { + // Baritone is running on top of forge with mods installed, perhaps? + name = loc.toString(); // include the namespace with the colon + } + return name; + } + + public static Block stringToBlock(String name) { + if (!name.contains(":")) { + name = "minecraft:" + name; + } + return Block.getBlockFromName(name); } private static PathingBlockType getPathingBlockType(Block block) { diff --git a/src/main/java/baritone/utils/ExampleBaritoneControl.java b/src/main/java/baritone/utils/ExampleBaritoneControl.java index d1fc14ee..78f418ea 100644 --- a/src/main/java/baritone/utils/ExampleBaritoneControl.java +++ b/src/main/java/baritone/utils/ExampleBaritoneControl.java @@ -21,21 +21,22 @@ import baritone.Baritone; import baritone.Settings; import baritone.behavior.Behavior; import baritone.behavior.impl.PathingBehavior; +import baritone.chunk.ChunkPacker; import baritone.chunk.Waypoint; import baritone.chunk.WorldProvider; import baritone.event.events.ChatEvent; import baritone.pathing.calc.AStarPathFinder; -import baritone.pathing.goals.Goal; -import baritone.pathing.goals.GoalBlock; -import baritone.pathing.goals.GoalXZ; -import baritone.pathing.goals.GoalYLevel; +import baritone.pathing.goals.*; import baritone.pathing.movement.ActionCosts; import baritone.pathing.movement.CalculationContext; import baritone.pathing.movement.Movement; import baritone.utils.pathing.BetterBlockPos; +import net.minecraft.block.Block; import net.minecraft.util.math.BlockPos; +import net.minecraft.world.chunk.EmptyChunk; import java.util.*; +import java.util.stream.Collectors; public class ExampleBaritoneControl extends Behavior { public static ExampleBaritoneControl INSTANCE = new ExampleBaritoneControl(); @@ -105,6 +106,57 @@ public class ExampleBaritoneControl extends Behavior { displayChatMessageRaw("ok canceled"); return; } + if (msg.toLowerCase().equals("reloadall")) { + WorldProvider.INSTANCE.getCurrentWorld().cache.reloadAllFromDisk(); + displayChatMessageRaw("ok"); + event.cancel(); + return; + } + if (msg.toLowerCase().equals("saveall")) { + WorldProvider.INSTANCE.getCurrentWorld().cache.save(); + displayChatMessageRaw("ok"); + event.cancel(); + return; + } + if (msg.toLowerCase().startsWith("find")) { + String blockType = msg.toLowerCase().substring(4).trim(); + LinkedList locs = WorldProvider.INSTANCE.getCurrentWorld().cache.getLocationsOf(blockType); + displayChatMessageRaw("Have " + locs.size() + " locations"); + for (BlockPos pos : locs) { + Block actually = BlockStateInterface.get(pos).getBlock(); + if (!ChunkPacker.blockToString(actually).equalsIgnoreCase(blockType)) { + System.out.println("Was looking for " + blockType + " but actually found " + actually + " " + ChunkPacker.blockToString(actually)); + } + } + event.cancel(); + return; + } + if (msg.toLowerCase().startsWith("mine")) { + String blockType = msg.toLowerCase().substring(4).trim(); + List locs = new ArrayList<>(WorldProvider.INSTANCE.getCurrentWorld().cache.getLocationsOf(blockType)); + if (locs.isEmpty()) { + displayChatMessageRaw("No locations known"); + event.cancel(); + return; + } + BlockPos playerFeet = playerFeet(); + locs.sort(Comparator.comparingDouble(pos -> playerFeet.distanceSq(pos))); + + // remove any that are within loaded chunks that aren't actually what we want + locs.removeAll(locs.stream() + .filter(pos -> !(world().getChunk(pos) instanceof EmptyChunk)) + .filter(pos -> !ChunkPacker.blockToString(BlockStateInterface.get(pos).getBlock()).equalsIgnoreCase(blockType)) + .collect(Collectors.toList())); + + if (locs.size() > 10) { + displayChatMessageRaw("Pathing to any of closest 10"); + locs = locs.subList(0, 10); + } + PathingBehavior.INSTANCE.setGoal(new GoalComposite(locs.stream().map(GoalTwoBlocks::new).toArray(Goal[]::new))); + PathingBehavior.INSTANCE.path(); + event.cancel(); + return; + } if (msg.toLowerCase().startsWith("thisway")) { Goal goal = GoalXZ.fromDirection(playerFeetAsVec(), player().rotationYaw, Double.parseDouble(msg.substring(7).trim())); PathingBehavior.INSTANCE.setGoal(goal); diff --git a/src/test/java/baritone/chunk/CachedRegionTest.java b/src/test/java/baritone/chunk/CachedRegionTest.java new file mode 100644 index 00000000..0992cee1 --- /dev/null +++ b/src/test/java/baritone/chunk/CachedRegionTest.java @@ -0,0 +1,50 @@ +/* + * This file is part of Baritone. + * + * Baritone is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Baritone. If not, see . + */ + +package baritone.chunk; + +import org.junit.Test; + +import static junit.framework.TestCase.assertEquals; + +public class CachedRegionTest { + + @Test + public void blockPosSaving() { + for (int x = 0; x < 16; x++) { + for (int z = 0; z < 16; z++) { + for (int y = 0; y < 256; y++) { + byte part1 = (byte) (z << 4 | x); + byte part2 = (byte) (y); + byte xz = part1; + int X = xz & 0x0f; + int Z = (xz >>> 4) & 0x0f; + int Y = (int) part2; + if (Y < 0) { + Y += 256; + } + if (x != X || y != Y || z != Z) { + System.out.println(x + " " + X + " " + y + " " + Y + " " + z + " " + Z); + } + assertEquals(x, X); + assertEquals(y, Y); + assertEquals(z, Z); + } + } + } + } +} \ No newline at end of file From 1889e374938dffa7b85c9e0442f67e91938ff931 Mon Sep 17 00:00:00 2001 From: Brady Date: Thu, 23 Aug 2018 15:05:37 -0500 Subject: [PATCH 18/86] Replace lambda with method reference --- src/main/java/baritone/utils/ExampleBaritoneControl.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/baritone/utils/ExampleBaritoneControl.java b/src/main/java/baritone/utils/ExampleBaritoneControl.java index 78f418ea..d54a035d 100644 --- a/src/main/java/baritone/utils/ExampleBaritoneControl.java +++ b/src/main/java/baritone/utils/ExampleBaritoneControl.java @@ -140,7 +140,7 @@ public class ExampleBaritoneControl extends Behavior { return; } BlockPos playerFeet = playerFeet(); - locs.sort(Comparator.comparingDouble(pos -> playerFeet.distanceSq(pos))); + locs.sort(Comparator.comparingDouble(playerFeet::distanceSq)); // remove any that are within loaded chunks that aren't actually what we want locs.removeAll(locs.stream() From 709822ef47fdf6121dc30f4fb3f994a8154e3b01 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Thu, 23 Aug 2018 13:12:13 -0700 Subject: [PATCH 19/86] only search nearby regions --- src/main/java/baritone/chunk/CachedWorld.java | 33 +++++++++++++++---- .../utils/ExampleBaritoneControl.java | 10 +++--- 2 files changed, 31 insertions(+), 12 deletions(-) diff --git a/src/main/java/baritone/chunk/CachedWorld.java b/src/main/java/baritone/chunk/CachedWorld.java index 3abcb8b3..20d58a38 100644 --- a/src/main/java/baritone/chunk/CachedWorld.java +++ b/src/main/java/baritone/chunk/CachedWorld.java @@ -85,13 +85,32 @@ public final class CachedWorld implements IBlockTypeAccess { return region.getBlock(x & 511, y, z & 511); } - public final LinkedList getLocationsOf(String block) { + public final LinkedList getLocationsOf(String block, int minimum, int maxRegionDistanceSq) { LinkedList res = new LinkedList<>(); - this.cachedRegions.values().forEach(region -> { - if (region != null) - for (BlockPos pos : region.getLocationsOf(block)) - res.add(pos); - }); + int playerRegionX = playerFeet().getX() >> 9; + int playerRegionZ = playerFeet().getZ() >> 9; + + int searchRadius = 0; + while (searchRadius <= maxRegionDistanceSq) { + for (int xoff = -searchRadius; xoff <= searchRadius; xoff++) { + for (int zoff = -searchRadius; zoff <= searchRadius; zoff++) { + double distance = xoff * xoff + zoff * zoff; + if (distance != searchRadius) { + continue; + } + int regionX = xoff + playerRegionX; + int regionZ = zoff + playerRegionZ; + CachedRegion region = getOrCreateRegion(regionX, regionZ); + if (region != null) + for (BlockPos pos : region.getLocationsOf(block)) + res.add(pos); + } + } + if (res.size() >= minimum) { + return res; + } + searchRadius++; + } return res; } @@ -139,7 +158,7 @@ public final class CachedWorld implements IBlockTypeAccess { * @param regionZ The region Z coordinate * @return The region located at the specified coordinates */ - private CachedRegion getOrCreateRegion(int regionX, int regionZ) { + private synchronized CachedRegion getOrCreateRegion(int regionX, int regionZ) { return cachedRegions.computeIfAbsent(getRegionID(regionX, regionZ), id -> { CachedRegion newRegion = new CachedRegion(regionX, regionZ); newRegion.load(this.directory); diff --git a/src/main/java/baritone/utils/ExampleBaritoneControl.java b/src/main/java/baritone/utils/ExampleBaritoneControl.java index 78f418ea..bf4a412f 100644 --- a/src/main/java/baritone/utils/ExampleBaritoneControl.java +++ b/src/main/java/baritone/utils/ExampleBaritoneControl.java @@ -120,7 +120,7 @@ public class ExampleBaritoneControl extends Behavior { } if (msg.toLowerCase().startsWith("find")) { String blockType = msg.toLowerCase().substring(4).trim(); - LinkedList locs = WorldProvider.INSTANCE.getCurrentWorld().cache.getLocationsOf(blockType); + LinkedList locs = WorldProvider.INSTANCE.getCurrentWorld().cache.getLocationsOf(blockType, 1, 4); displayChatMessageRaw("Have " + locs.size() + " locations"); for (BlockPos pos : locs) { Block actually = BlockStateInterface.get(pos).getBlock(); @@ -133,7 +133,7 @@ public class ExampleBaritoneControl extends Behavior { } if (msg.toLowerCase().startsWith("mine")) { String blockType = msg.toLowerCase().substring(4).trim(); - List locs = new ArrayList<>(WorldProvider.INSTANCE.getCurrentWorld().cache.getLocationsOf(blockType)); + List locs = new ArrayList<>(WorldProvider.INSTANCE.getCurrentWorld().cache.getLocationsOf(1, 1)); if (locs.isEmpty()) { displayChatMessageRaw("No locations known"); event.cancel(); @@ -148,9 +148,9 @@ public class ExampleBaritoneControl extends Behavior { .filter(pos -> !ChunkPacker.blockToString(BlockStateInterface.get(pos).getBlock()).equalsIgnoreCase(blockType)) .collect(Collectors.toList())); - if (locs.size() > 10) { - displayChatMessageRaw("Pathing to any of closest 10"); - locs = locs.subList(0, 10); + if (locs.size() > 30) { + displayChatMessageRaw("Pathing to any of closest 30"); + locs = locs.subList(0, 30); } PathingBehavior.INSTANCE.setGoal(new GoalComposite(locs.stream().map(GoalTwoBlocks::new).toArray(Goal[]::new))); PathingBehavior.INSTANCE.path(); From b56dde8f7ec11761a3e9f63167e5cd8dd7d20f66 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Thu, 23 Aug 2018 13:17:29 -0700 Subject: [PATCH 20/86] typo --- src/main/java/baritone/utils/ExampleBaritoneControl.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/baritone/utils/ExampleBaritoneControl.java b/src/main/java/baritone/utils/ExampleBaritoneControl.java index 24b50b8b..fbd801f3 100644 --- a/src/main/java/baritone/utils/ExampleBaritoneControl.java +++ b/src/main/java/baritone/utils/ExampleBaritoneControl.java @@ -133,7 +133,7 @@ public class ExampleBaritoneControl extends Behavior { } if (msg.toLowerCase().startsWith("mine")) { String blockType = msg.toLowerCase().substring(4).trim(); - List locs = new ArrayList<>(WorldProvider.INSTANCE.getCurrentWorld().cache.getLocationsOf(1, 1)); + List locs = new ArrayList<>(WorldProvider.INSTANCE.getCurrentWorld().cache.getLocationsOf(blockType, 1, 1)); if (locs.isEmpty()) { displayChatMessageRaw("No locations known"); event.cancel(); From 14df84ef0e4656eb5ea2e5dd7b6c67b9fcb1fce6 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Thu, 23 Aug 2018 13:39:13 -0700 Subject: [PATCH 21/86] chunk caching either way --- src/main/java/baritone/chunk/CachedWorld.java | 5 +++ .../java/baritone/event/GameEventHandler.java | 35 +++++++++---------- .../pathing/calc/AStarPathFinder.java | 11 +++--- .../baritone/utils/BlockStateInterface.java | 15 ++++---- 4 files changed, 32 insertions(+), 34 deletions(-) diff --git a/src/main/java/baritone/chunk/CachedWorld.java b/src/main/java/baritone/chunk/CachedWorld.java index 20d58a38..a2a2fd6e 100644 --- a/src/main/java/baritone/chunk/CachedWorld.java +++ b/src/main/java/baritone/chunk/CachedWorld.java @@ -17,6 +17,7 @@ package baritone.chunk; +import baritone.Baritone; import baritone.utils.pathing.IBlockTypeAccess; import it.unimi.dsi.fastutil.longs.Long2ObjectMap; import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap; @@ -120,6 +121,10 @@ public final class CachedWorld implements IBlockTypeAccess { } public final void save() { + if (!Baritone.settings().chunkCaching.get()) { + System.out.println("Not saving to disk; chunk caching is disabled."); + return; + } long start = System.currentTimeMillis(); this.cachedRegions.values().forEach(region -> { if (region != null) diff --git a/src/main/java/baritone/event/GameEventHandler.java b/src/main/java/baritone/event/GameEventHandler.java index bfc42219..7185b632 100644 --- a/src/main/java/baritone/event/GameEventHandler.java +++ b/src/main/java/baritone/event/GameEventHandler.java @@ -111,15 +111,14 @@ public final class GameEventHandler implements IGameEventListener, Helper { && type == ChunkEvent.Type.UNLOAD && mc.world.getChunkProvider().isChunkGeneratedAt(event.getX(), event.getZ()); - if (Baritone.settings().chunkCaching.get()) { - if (isPostPopulate || isPreUnload) { - WorldProvider.INSTANCE.ifWorldLoaded(world -> { - Chunk chunk = mc.world.getChunk(event.getX(), event.getZ()); - world.cache.queueForPacking(chunk); - }); - } + if (isPostPopulate || isPreUnload) { + WorldProvider.INSTANCE.ifWorldLoaded(world -> { + Chunk chunk = mc.world.getChunk(event.getX(), event.getZ()); + world.cache.queueForPacking(chunk); + }); } + dispatch(listener -> listener.onChunkEvent(event)); } @@ -136,19 +135,17 @@ public final class GameEventHandler implements IGameEventListener, Helper { @Override public final void onWorldEvent(WorldEvent event) { - if (Baritone.settings().chunkCaching.get()) { - WorldProvider cache = WorldProvider.INSTANCE; + WorldProvider cache = WorldProvider.INSTANCE; - switch (event.getState()) { - case PRE: - cache.closeWorld(); - break; - case POST: - cache.closeWorld(); - if (event.getWorld() != null) - cache.initWorld(event.getWorld()); - break; - } + switch (event.getState()) { + case PRE: + cache.closeWorld(); + break; + case POST: + cache.closeWorld(); + if (event.getWorld() != null) + cache.initWorld(event.getWorld()); + break; } dispatch(listener -> listener.onWorldEvent(event)); diff --git a/src/main/java/baritone/pathing/calc/AStarPathFinder.java b/src/main/java/baritone/pathing/calc/AStarPathFinder.java index 6d8b3ac7..2c1df800 100644 --- a/src/main/java/baritone/pathing/calc/AStarPathFinder.java +++ b/src/main/java/baritone/pathing/calc/AStarPathFinder.java @@ -77,8 +77,7 @@ public class AStarPathFinder extends AbstractNodeCostSearch implements Helper { int numNodes = 0; int numEmptyChunk = 0; boolean favoring = favoredPositions.isPresent(); - boolean cache = Baritone.settings().chunkCaching.get(); // grab all settings beforehand so that changing settings during pathing doesn't cause a crash or unpredictable behavior - int pathingMaxChunkBorderFetch = Baritone.settings().pathingMaxChunkBorderFetch.get(); + int pathingMaxChunkBorderFetch = Baritone.settings().pathingMaxChunkBorderFetch.get(); // grab all settings beforehand so that changing settings during pathing doesn't cause a crash or unpredictable behavior double favorCoeff = Baritone.settings().backtrackCostFavoringCoefficient.get(); boolean minimumImprovementRepropagation = Baritone.settings().minimumImprovementRepropagation.get(); while (!openSet.isEmpty() && numEmptyChunk < pathingMaxChunkBorderFetch && System.currentTimeMillis() < timeoutTime) { @@ -112,11 +111,9 @@ public class AStarPathFinder extends AbstractNodeCostSearch implements Helper { } BetterBlockPos dest = (BetterBlockPos) movementToGetToNeighbor.getDest(); boolean isPositionCached = false; - if (cache) { - if (WorldProvider.INSTANCE.getCurrentWorld() != null) { - if (WorldProvider.INSTANCE.getCurrentWorld().cache.getBlock(dest) != null) { - isPositionCached = true; - } + if (WorldProvider.INSTANCE.getCurrentWorld() != null) { + if (WorldProvider.INSTANCE.getCurrentWorld().cache.getBlock(dest) != null) { + isPositionCached = true; } } if (!isPositionCached && Minecraft.getMinecraft().world.getChunk(dest) instanceof EmptyChunk) { diff --git a/src/main/java/baritone/utils/BlockStateInterface.java b/src/main/java/baritone/utils/BlockStateInterface.java index 1c23e74a..a1013d7f 100644 --- a/src/main/java/baritone/utils/BlockStateInterface.java +++ b/src/main/java/baritone/utils/BlockStateInterface.java @@ -18,7 +18,7 @@ package baritone.utils; import baritone.Baritone; -import baritone.chunk.CachedWorld; +import baritone.chunk.WorldData; import baritone.chunk.WorldProvider; import net.minecraft.block.Block; import net.minecraft.block.BlockFalling; @@ -42,16 +42,15 @@ public class BlockStateInterface implements Helper { return chunk.getBlockState(pos); } } - if (Baritone.settings().chunkCaching.get()) { - CachedWorld world = WorldProvider.INSTANCE.getCurrentWorld().cache; - if (world != null) { - IBlockState type = world.getBlock(pos); - if (type != null) { - return type; - } + WorldData world = WorldProvider.INSTANCE.getCurrentWorld(); + if (world != null) { + IBlockState type = world.cache.getBlock(pos); + if (type != null) { + return type; } } + return Blocks.AIR.getDefaultState(); } From cacd2096ecd2fd6f6d67bf128d6e1dbcd1e8cec7 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Thu, 23 Aug 2018 13:42:45 -0700 Subject: [PATCH 22/86] save regularly --- src/main/java/baritone/chunk/CachedWorld.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/src/main/java/baritone/chunk/CachedWorld.java b/src/main/java/baritone/chunk/CachedWorld.java index a2a2fd6e..7c86db0f 100644 --- a/src/main/java/baritone/chunk/CachedWorld.java +++ b/src/main/java/baritone/chunk/CachedWorld.java @@ -66,6 +66,21 @@ public final class CachedWorld implements IBlockTypeAccess { // Insert an invalid region element cachedRegions.put(0, null); new PackerThread().start(); + new Thread() { + public void run() { + try { + while (true) { + // since a region only saves if it's been modified since its last save + // saving every 10 minutes means that once it's time to exit + // we'll only have a couple regions to save + save(); + Thread.sleep(600000); + } + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + }.start(); } public final void queueForPacking(Chunk chunk) { From c4cc0c6cdf13958d3be55224102e906673da8ae7 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Thu, 23 Aug 2018 13:47:01 -0700 Subject: [PATCH 23/86] cleanup to cachedregion --- .../java/baritone/chunk/CachedRegion.java | 32 +++---------------- 1 file changed, 4 insertions(+), 28 deletions(-) diff --git a/src/main/java/baritone/chunk/CachedRegion.java b/src/main/java/baritone/chunk/CachedRegion.java index b9e0e4e0..385a206c 100644 --- a/src/main/java/baritone/chunk/CachedRegion.java +++ b/src/main/java/baritone/chunk/CachedRegion.java @@ -26,7 +26,6 @@ import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; import java.util.*; -import java.util.function.Consumer; import java.util.zip.GZIPInputStream; import java.util.zip.GZIPOutputStream; @@ -71,7 +70,7 @@ public final class CachedRegion implements IBlockTypeAccess { @Override public final IBlockState getBlock(int x, int y, int z) { - CachedChunk chunk = this.getChunk(x >> 4, z >> 4); + CachedChunk chunk = chunks[x >> 4][z >> 4]; if (chunk != null) { return chunk.getBlock(x & 15, y, z & 15); } @@ -97,27 +96,13 @@ public final class CachedRegion implements IBlockTypeAccess { return res; } - final void updateCachedChunk(int chunkX, int chunkZ, CachedChunk chunk) { + final synchronized void updateCachedChunk(int chunkX, int chunkZ, CachedChunk chunk) { this.chunks[chunkX][chunkZ] = chunk; hasUnsavedChanges = true; } - private CachedChunk getChunk(int chunkX, int chunkZ) { - return this.chunks[chunkX][chunkZ]; - } - public void forEachChunk(Consumer consumer) { - for (int x = 0; x < 32; x++) { - for (int z = 0; z < 32; z++) { - CachedChunk chunk = getChunk(x, z); - if (chunk != null) { - consumer.accept(chunk); - } - } - } - } - - public final void save(String directory) { + public synchronized final void save(String directory) { if (!hasUnsavedChanges) { return; } @@ -184,7 +169,7 @@ public final class CachedRegion implements IBlockTypeAccess { } } - public void load(String directory) { + public synchronized void load(String directory) { try { Path path = Paths.get(directory); if (!Files.exists(path)) @@ -285,15 +270,6 @@ public final class CachedRegion implements IBlockTypeAccess { } } - private static boolean isAllZeros(final byte[] array) { - for (byte b : array) { - if (b != 0) { - return false; - } - } - return true; - } - /** * @return The region x coordinate */ From 9a065f55ccdc8a1a8925c3e166f3f1c2b95c9485 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Thu, 23 Aug 2018 14:02:05 -0700 Subject: [PATCH 24/86] some more blocks to cache --- src/main/java/baritone/chunk/CachedChunk.java | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/main/java/baritone/chunk/CachedChunk.java b/src/main/java/baritone/chunk/CachedChunk.java index fca8034d..520bcbea 100644 --- a/src/main/java/baritone/chunk/CachedChunk.java +++ b/src/main/java/baritone/chunk/CachedChunk.java @@ -56,6 +56,13 @@ public final class CachedChunk implements IBlockTypeAccess { add(Blocks.BEACON); add(Blocks.BREWING_STAND); add(Blocks.SKULL); + add(Blocks.ENCHANTING_TABLE); + add(Blocks.ANVIL); + add(Blocks.LIT_FURNACE); + add(Blocks.BED); + add(Blocks.DRAGON_EGG); + add(Blocks.JUKEBOX); + add(Blocks.END_GATEWAY); }}); /** From b3189721a6fb010da52821439039e2900064a4a7 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Thu, 23 Aug 2018 14:37:08 -0700 Subject: [PATCH 25/86] add explanation --- src/main/java/baritone/chunk/WorldProvider.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/main/java/baritone/chunk/WorldProvider.java b/src/main/java/baritone/chunk/WorldProvider.java index af18e922..1006b53b 100644 --- a/src/main/java/baritone/chunk/WorldProvider.java +++ b/src/main/java/baritone/chunk/WorldProvider.java @@ -26,6 +26,7 @@ import net.minecraft.server.integrated.IntegratedServer; import net.minecraft.world.WorldServer; import java.io.File; +import java.io.FileOutputStream; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; @@ -70,6 +71,11 @@ public enum WorldProvider implements Helper { //remote directory = new File(Baritone.INSTANCE.getDir(), mc.getCurrentServerData().serverIP); } + // lol wtf is this baritone folder in my minecraft? + try (FileOutputStream out = new FileOutputStream(new File(directory, "readme.txt"))) { + // good thing we have a readme + out.write("https://github.com/cabaletta/baritone\n".getBytes()); + } catch (IOException ex) {} directory = new File(directory, "DIM" + dimensionID); Path dir = directory.toPath(); if (!Files.exists(dir)) { From 559bc46702db7b9ab3b7f6bb3a989ee4f1763437 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Thu, 23 Aug 2018 14:40:42 -0700 Subject: [PATCH 26/86] put it in the right place --- src/main/java/baritone/chunk/WorldProvider.java | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/src/main/java/baritone/chunk/WorldProvider.java b/src/main/java/baritone/chunk/WorldProvider.java index 1006b53b..9cb60c9d 100644 --- a/src/main/java/baritone/chunk/WorldProvider.java +++ b/src/main/java/baritone/chunk/WorldProvider.java @@ -53,6 +53,7 @@ public enum WorldProvider implements Helper { public final void initWorld(WorldClient world) { int dimensionID = world.provider.getDimensionType().getId(); File directory; + File readme; IntegratedServer integratedServer = mc.getIntegratedServer(); if (integratedServer != null) { WorldServer localServerWorld = integratedServer.getWorld(dimensionID); @@ -66,16 +67,19 @@ public enum WorldProvider implements Helper { } directory = new File(directory, "baritone"); - + readme = directory; + } else { //remote directory = new File(Baritone.INSTANCE.getDir(), mc.getCurrentServerData().serverIP); + readme = Baritone.INSTANCE.getDir(); } - // lol wtf is this baritone folder in my minecraft? - try (FileOutputStream out = new FileOutputStream(new File(directory, "readme.txt"))) { + // lol wtf is this baritone folder in my minecraft save? + try (FileOutputStream out = new FileOutputStream(new File(readme, "readme.txt"))) { // good thing we have a readme out.write("https://github.com/cabaletta/baritone\n".getBytes()); } catch (IOException ex) {} + directory = new File(directory, "DIM" + dimensionID); Path dir = directory.toPath(); if (!Files.exists(dir)) { From d17122a777b7d695a94e6757a9f4f0272d7f5653 Mon Sep 17 00:00:00 2001 From: Brady Date: Thu, 23 Aug 2018 17:01:51 -0500 Subject: [PATCH 27/86] Fix some mixins which referenced a non-obfuscated method --- src/main/java/baritone/launch/mixins/MixinGameSettings.java | 3 ++- src/main/java/baritone/launch/mixins/MixinGuiContainer.java | 3 ++- src/main/java/baritone/launch/mixins/MixinGuiScreen.java | 3 ++- src/main/java/baritone/launch/mixins/MixinMinecraft.java | 3 ++- 4 files changed, 8 insertions(+), 4 deletions(-) diff --git a/src/main/java/baritone/launch/mixins/MixinGameSettings.java b/src/main/java/baritone/launch/mixins/MixinGameSettings.java index 2179affb..b68cce51 100755 --- a/src/main/java/baritone/launch/mixins/MixinGameSettings.java +++ b/src/main/java/baritone/launch/mixins/MixinGameSettings.java @@ -34,7 +34,8 @@ public class MixinGameSettings { method = "isKeyDown", at = @At( value = "INVOKE", - target = "org/lwjgl/input/Keyboard.isKeyDown(I)Z" + target = "org/lwjgl/input/Keyboard.isKeyDown(I)Z", + remap = false ) ) private static boolean isKeyDown(int keyCode) { diff --git a/src/main/java/baritone/launch/mixins/MixinGuiContainer.java b/src/main/java/baritone/launch/mixins/MixinGuiContainer.java index 6d37ab97..dd9bf715 100755 --- a/src/main/java/baritone/launch/mixins/MixinGuiContainer.java +++ b/src/main/java/baritone/launch/mixins/MixinGuiContainer.java @@ -37,7 +37,8 @@ public class MixinGuiContainer { }, at = @At( value = "INVOKE", - target = "org/lwjgl/input/Keyboard.isKeyDown(I)Z" + target = "org/lwjgl/input/Keyboard.isKeyDown(I)Z", + remap = false ) ) private boolean isKeyDown(int keyCode) { diff --git a/src/main/java/baritone/launch/mixins/MixinGuiScreen.java b/src/main/java/baritone/launch/mixins/MixinGuiScreen.java index 81bf1bf5..47877058 100755 --- a/src/main/java/baritone/launch/mixins/MixinGuiScreen.java +++ b/src/main/java/baritone/launch/mixins/MixinGuiScreen.java @@ -38,7 +38,8 @@ public class MixinGuiScreen { }, at = @At( value = "INVOKE", - target = "org/lwjgl/input/Keyboard.isKeyDown(I)Z" + target = "org/lwjgl/input/Keyboard.isKeyDown(I)Z", + remap = false ) ) private static boolean isKeyDown(int keyCode) { diff --git a/src/main/java/baritone/launch/mixins/MixinMinecraft.java b/src/main/java/baritone/launch/mixins/MixinMinecraft.java index f7bf4d36..653c233c 100755 --- a/src/main/java/baritone/launch/mixins/MixinMinecraft.java +++ b/src/main/java/baritone/launch/mixins/MixinMinecraft.java @@ -84,7 +84,8 @@ public class MixinMinecraft { method = "runTickKeyboard", at = @At( value = "INVOKE", - target = "org/lwjgl/input/Keyboard.isKeyDown(I)Z" + target = "org/lwjgl/input/Keyboard.isKeyDown(I)Z", + remap = false ) ) private boolean Keyboard$isKeyDown(int keyCode) { From c14f0dac8f4f48d210da62a16f9b68526e96d6b3 Mon Sep 17 00:00:00 2001 From: Brady Date: Thu, 23 Aug 2018 17:04:00 -0500 Subject: [PATCH 28/86] Remove MixinMain Was a misinterpretation of something Leijurv didn't actually add ?? --- .../baritone/launch/mixins/MixinMain.java | 40 ------------------- src/main/resources/mixins.baritone.json | 1 - 2 files changed, 41 deletions(-) delete mode 100755 src/main/java/baritone/launch/mixins/MixinMain.java diff --git a/src/main/java/baritone/launch/mixins/MixinMain.java b/src/main/java/baritone/launch/mixins/MixinMain.java deleted file mode 100755 index 1e4323e9..00000000 --- a/src/main/java/baritone/launch/mixins/MixinMain.java +++ /dev/null @@ -1,40 +0,0 @@ -/* - * This file is part of Baritone. - * - * Baritone is free software: you can redistribute it and/or modify - * it under the terms of the GNU 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 General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Baritone. If not, see . - */ - -package baritone.launch.mixins; - -import net.minecraft.client.main.Main; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.injection.At; -import org.spongepowered.asm.mixin.injection.Inject; -import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; - -/** - * @author Brady - * @since 7/31/2018 10:18 PM - */ -@Mixin(Main.class) -public class MixinMain { - - @Inject( - method = "main", - at = @At("HEAD") - ) - private static void main(String[] args, CallbackInfo ci) { - System.setProperty("java.net.preferIPv4Stack", "true"); - } -} diff --git a/src/main/resources/mixins.baritone.json b/src/main/resources/mixins.baritone.json index e05bca84..e4d09c71 100755 --- a/src/main/resources/mixins.baritone.json +++ b/src/main/resources/mixins.baritone.json @@ -17,7 +17,6 @@ "MixinGuiScreen", "MixinInventoryPlayer", "MixinKeyBinding", - "MixinMain", "MixinMinecraft", "MixinNetHandlerPlayClient", "MixinNetworkManager", From 90316b3359897df32565c0c6eff9589281c6cb45 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Thu, 23 Aug 2018 15:13:20 -0700 Subject: [PATCH 29/86] useless --- src/main/java/baritone/pathing/path/IPath.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/baritone/pathing/path/IPath.java b/src/main/java/baritone/pathing/path/IPath.java index c01c7f53..39c17993 100644 --- a/src/main/java/baritone/pathing/path/IPath.java +++ b/src/main/java/baritone/pathing/path/IPath.java @@ -146,7 +146,7 @@ public interface IPath extends Helper { } double factor = Baritone.settings().pathCutoffFactor.get(); int newLength = (int) (length() * factor); - displayChatMessageRaw("Static cutoff " + length() + " to " + newLength); + //displayChatMessageRaw("Static cutoff " + length() + " to " + newLength); return new CutoffPath(this, newLength); } } From 28be7121e3e712473c08538f19c9b8a0a4727438 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Thu, 23 Aug 2018 15:39:02 -0700 Subject: [PATCH 30/86] path event --- .../behavior/impl/PathingBehavior.java | 43 +++++++++++++++---- .../java/baritone/event/GameEventHandler.java | 32 +++----------- .../java/baritone/event/events/PathEvent.java | 22 ++++++++++ .../listener/AbstractGameEventListener.java | 6 ++- .../event/listener/IGameEventListener.java | 7 +++ 5 files changed, 73 insertions(+), 37 deletions(-) create mode 100644 src/main/java/baritone/event/events/PathEvent.java diff --git a/src/main/java/baritone/behavior/impl/PathingBehavior.java b/src/main/java/baritone/behavior/impl/PathingBehavior.java index b35baca1..de322b98 100644 --- a/src/main/java/baritone/behavior/impl/PathingBehavior.java +++ b/src/main/java/baritone/behavior/impl/PathingBehavior.java @@ -19,6 +19,7 @@ package baritone.behavior.impl; import baritone.Baritone; import baritone.behavior.Behavior; +import baritone.event.events.PathEvent; import baritone.event.events.PlayerUpdateEvent; import baritone.event.events.RenderEvent; import baritone.event.events.TickEvent; @@ -59,6 +60,14 @@ public class PathingBehavior extends Behavior { private boolean lastAutoJump; + private void dispatchPathEvent(PathEvent event) { + new Thread() { + public void run() { + Baritone.INSTANCE.getGameEventHandler().onPathEvent(event); + } + }.start(); + } + @Override public void onTick(TickEvent event) { if (event.getType() == TickEvent.Type.OUT) { @@ -74,6 +83,7 @@ public class PathingBehavior extends Behavior { current = null; if (goal == null || goal.isInGoal(playerFeet())) { displayChatMessageRaw("All done. At " + goal); + dispatchPathEvent(PathEvent.AT_GOAL); next = null; return; } @@ -85,10 +95,12 @@ public class PathingBehavior extends Behavior { // but if we fail in the middle of current // we're nowhere close to our planned ahead path // so need to discard it sadly. + dispatchPathEvent(PathEvent.DISCARD_NEXT); next = null; } if (next != null) { displayChatMessageRaw("Continuing on to planned next path"); + dispatchPathEvent(PathEvent.CONTINUING_ONTO_PLANNED_NEXT); current = next; next = null; return; @@ -96,9 +108,11 @@ public class PathingBehavior extends Behavior { // at this point, current just ended, but we aren't in the goal and have no plan for the future synchronized (pathCalcLock) { if (isPathCalcInProgress) { + dispatchPathEvent(PathEvent.PATH_FINISHED_NEXT_STILL_CALCULATING); // if we aren't calculating right now return; } + dispatchPathEvent(PathEvent.CALC_STARTED); findPathInNewThread(pathStart(), true, Optional.empty()); } return; @@ -110,6 +124,7 @@ public class PathingBehavior extends Behavior { if (next.getPath().positions().contains(playerFeet())) { // jump directly onto the next path displayChatMessageRaw("Splicing into planned next path early..."); + dispatchPathEvent(PathEvent.SPLICING_ONTO_NEXT_EARLY); current = next; next = null; return; @@ -132,6 +147,7 @@ public class PathingBehavior extends Behavior { if (ticksRemainingInSegment().get() < Baritone.settings().planningTickLookAhead.get()) { // and this path has 5 seconds or less left displayChatMessageRaw("Path almost over. Planning ahead..."); + dispatchPathEvent(PathEvent.NEXT_SEGMENT_CALC_STARTED); findPathInNewThread(current.getPath().getDest(), false, Optional.of(current.getPath())); } } @@ -192,6 +208,7 @@ public class PathingBehavior extends Behavior { if (isPathCalcInProgress) { return; } + dispatchPathEvent(PathEvent.CALC_STARTED); findPathInNewThread(pathStart(), true, Optional.empty()); } } @@ -227,19 +244,29 @@ public class PathingBehavior extends Behavior { if (Baritone.settings().cutoffAtLoadBoundary.get()) { path = path.map(IPath::cutoffAtLoadedChunks); } - path.map(p -> p.staticCutoff(goal)).map(PathExecutor::new).ifPresent(p -> { - synchronized (pathPlanLock) { - if (current == null) { - current = p; + Optional executor = path.map(p -> p.staticCutoff(goal)).map(PathExecutor::new); + synchronized (pathPlanLock) { + if (current == null) { + if (executor.isPresent()) { + dispatchPathEvent(PathEvent.CALC_FINISHED_NOW_EXECUTING); + current = executor.get(); } else { - if (next == null) { - next = p; + dispatchPathEvent(PathEvent.CALC_FAILED); + } + } else { + if (next == null) { + if (executor.isPresent()) { + dispatchPathEvent(PathEvent.NEXT_SEGMENT_CALC_FINISHED); + next = executor.get(); } else { - throw new IllegalStateException("I have no idea what to do with this path"); + dispatchPathEvent(PathEvent.NEXT_CALC_FAILED); } + } else { + throw new IllegalStateException("I have no idea what to do with this path"); } } - }); + } + if (talkAboutIt && current != null && current.getPath() != null) { if (goal == null || goal.isInGoal(current.getPath().getDest())) { displayChatMessageRaw("Finished finding a path from " + start + " to " + goal + ". " + current.getPath().getNumNodesConsidered() + " nodes considered"); diff --git a/src/main/java/baritone/event/GameEventHandler.java b/src/main/java/baritone/event/GameEventHandler.java index 7185b632..02c7f393 100644 --- a/src/main/java/baritone/event/GameEventHandler.java +++ b/src/main/java/baritone/event/GameEventHandler.java @@ -42,10 +42,6 @@ import baritone.event.listener.IGameEventListener; import baritone.utils.Helper; import baritone.utils.InputOverrideHandler; import baritone.utils.interfaces.Toggleable; -import net.minecraft.client.renderer.BufferBuilder; -import net.minecraft.client.renderer.GlStateManager; -import net.minecraft.client.renderer.Tessellator; -import net.minecraft.client.renderer.vertex.DefaultVertexFormats; import net.minecraft.client.settings.KeyBinding; import net.minecraft.world.chunk.Chunk; import org.lwjgl.input.Keyboard; @@ -181,6 +177,11 @@ public final class GameEventHandler implements IGameEventListener, Helper { dispatch(IGameEventListener::onPlayerDeath); } + @Override + public void onPathEvent(PathEvent event) { + dispatch(listener -> listener.onPathEvent(event)); + } + public final void registerEventListener(IGameEventListener listener) { this.listeners.add(listener); } @@ -192,27 +193,4 @@ public final class GameEventHandler implements IGameEventListener, Helper { private boolean canDispatch(IGameEventListener listener) { return !(listener instanceof Toggleable) || ((Toggleable) listener).isEnabled(); } - - private void drawChunkLine(int posX, int posZ, float partialTicks) { - GlStateManager.enableBlend(); - GlStateManager.tryBlendFuncSeparate(770, 771, 1, 0); - GlStateManager.color(1.0F, 1.0F, 0.0F, 0.4F); - GlStateManager.glLineWidth(2.0F); - GlStateManager.disableTexture2D(); - - Tessellator tessellator = Tessellator.getInstance(); - BufferBuilder buffer = tessellator.getBuffer(); - double d0 = mc.getRenderManager().viewerPosX; - double d1 = mc.getRenderManager().viewerPosY; - double d2 = mc.getRenderManager().viewerPosZ; - buffer.begin(3, DefaultVertexFormats.POSITION); - buffer.pos(posX - d0, 0 - d1, posZ - d2).endVertex(); - buffer.pos(posX - d0, 256 - d1, posZ - d2).endVertex(); - tessellator.draw(); - - GlStateManager.enableDepth(); - GlStateManager.depthMask(true); - GlStateManager.enableTexture2D(); - GlStateManager.disableBlend(); - } } diff --git a/src/main/java/baritone/event/events/PathEvent.java b/src/main/java/baritone/event/events/PathEvent.java new file mode 100644 index 00000000..0b110899 --- /dev/null +++ b/src/main/java/baritone/event/events/PathEvent.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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Baritone. If not, see . + */ + +package baritone.event.events; + +public enum PathEvent { + CALC_STARTED, CALC_FINISHED_NOW_EXECUTING, CALC_FAILED, NEXT_SEGMENT_CALC_STARTED, NEXT_SEGMENT_CALC_FINISHED, CONTINUING_ONTO_PLANNED_NEXT, SPLICING_ONTO_NEXT_EARLY, AT_GOAL, PATH_FINISHED_NEXT_STILL_CALCULATING, NEXT_CALC_FAILED, DISCARD_NEXT; +} diff --git a/src/main/java/baritone/event/listener/AbstractGameEventListener.java b/src/main/java/baritone/event/listener/AbstractGameEventListener.java index 0f113119..4b8de23a 100644 --- a/src/main/java/baritone/event/listener/AbstractGameEventListener.java +++ b/src/main/java/baritone/event/listener/AbstractGameEventListener.java @@ -41,9 +41,8 @@ import baritone.event.events.*; * overridden with empty bodies, allowing inheritors of this class to choose * which events they would like to listen in on. * - * @see IGameEventListener - * * @author Brady + * @see IGameEventListener * @since 8/1/2018 6:29 PM */ public interface AbstractGameEventListener extends IGameEventListener { @@ -86,4 +85,7 @@ public interface AbstractGameEventListener extends IGameEventListener { @Override default void onPlayerDeath() {} + + @Override + default void onPathEvent(PathEvent event) {} } diff --git a/src/main/java/baritone/event/listener/IGameEventListener.java b/src/main/java/baritone/event/listener/IGameEventListener.java index bb52a66d..4900f1eb 100644 --- a/src/main/java/baritone/event/listener/IGameEventListener.java +++ b/src/main/java/baritone/event/listener/IGameEventListener.java @@ -149,4 +149,11 @@ public interface IGameEventListener { * @see GuiGameOver(ITextComponent) */ void onPlayerDeath(); + + /** + * When the pathfinder's state changes + * + * @param event + */ + void onPathEvent(PathEvent event); } From 9accdf097fab174adeaa8761cd47be0e52b944fe Mon Sep 17 00:00:00 2001 From: Leijurv Date: Thu, 23 Aug 2018 15:55:25 -0700 Subject: [PATCH 31/86] single threaded --- .../java/baritone/behavior/impl/PathingBehavior.java | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/main/java/baritone/behavior/impl/PathingBehavior.java b/src/main/java/baritone/behavior/impl/PathingBehavior.java index de322b98..0b9accb9 100644 --- a/src/main/java/baritone/behavior/impl/PathingBehavior.java +++ b/src/main/java/baritone/behavior/impl/PathingBehavior.java @@ -61,11 +61,11 @@ public class PathingBehavior extends Behavior { private boolean lastAutoJump; private void dispatchPathEvent(PathEvent event) { - new Thread() { - public void run() { - Baritone.INSTANCE.getGameEventHandler().onPathEvent(event); - } - }.start(); + //new Thread() { + // public void run() { + Baritone.INSTANCE.getGameEventHandler().onPathEvent(event); + // } + //}.start(); } @Override From e85f439c0fff90a01cc3e3a83525280df803265e Mon Sep 17 00:00:00 2001 From: Leijurv Date: Thu, 23 Aug 2018 15:57:29 -0700 Subject: [PATCH 32/86] multi threaded --- .../java/baritone/behavior/impl/PathingBehavior.java | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/main/java/baritone/behavior/impl/PathingBehavior.java b/src/main/java/baritone/behavior/impl/PathingBehavior.java index 0b9accb9..de322b98 100644 --- a/src/main/java/baritone/behavior/impl/PathingBehavior.java +++ b/src/main/java/baritone/behavior/impl/PathingBehavior.java @@ -61,11 +61,11 @@ public class PathingBehavior extends Behavior { private boolean lastAutoJump; private void dispatchPathEvent(PathEvent event) { - //new Thread() { - // public void run() { - Baritone.INSTANCE.getGameEventHandler().onPathEvent(event); - // } - //}.start(); + new Thread() { + public void run() { + Baritone.INSTANCE.getGameEventHandler().onPathEvent(event); + } + }.start(); } @Override From 40545c0c5de71f78c8529818e4e584a537ef1d8e Mon Sep 17 00:00:00 2001 From: Brady Date: Thu, 23 Aug 2018 18:34:40 -0500 Subject: [PATCH 33/86] Add player null check to our allowUserInput hook, fixes #81 --- src/main/java/baritone/launch/mixins/MixinMinecraft.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/main/java/baritone/launch/mixins/MixinMinecraft.java b/src/main/java/baritone/launch/mixins/MixinMinecraft.java index 653c233c..2bb04ef8 100755 --- a/src/main/java/baritone/launch/mixins/MixinMinecraft.java +++ b/src/main/java/baritone/launch/mixins/MixinMinecraft.java @@ -25,6 +25,7 @@ import baritone.event.events.WorldEvent; import baritone.event.events.type.EventState; import baritone.utils.ExampleBaritoneControl; import net.minecraft.client.Minecraft; +import net.minecraft.client.entity.EntityPlayerSP; import net.minecraft.client.gui.GuiScreen; import net.minecraft.client.multiplayer.WorldClient; import net.minecraft.item.ItemStack; @@ -48,6 +49,7 @@ import org.spongepowered.asm.mixin.injection.callback.LocalCapture; public class MixinMinecraft { @Shadow private int leftClickCounter; + @Shadow public EntityPlayerSP player; @Shadow public WorldClient world; @Inject( @@ -160,7 +162,7 @@ public class MixinMinecraft { ) ) private boolean isAllowUserInput(GuiScreen screen) { - return PathingBehavior.INSTANCE.getCurrent() != null || screen.allowUserInput; + return (PathingBehavior.INSTANCE.getCurrent() != null && player != null) || screen.allowUserInput; } @Inject( From 54151b9a302a3c0dae0f4a79b42be319f62faf12 Mon Sep 17 00:00:00 2001 From: Brady Date: Thu, 23 Aug 2018 18:43:24 -0500 Subject: [PATCH 34/86] Fix baritone not using its own refmap --- src/main/resources/mixins.baritone.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/resources/mixins.baritone.json b/src/main/resources/mixins.baritone.json index e4d09c71..fcbfca77 100755 --- a/src/main/resources/mixins.baritone.json +++ b/src/main/resources/mixins.baritone.json @@ -1,7 +1,7 @@ { "required": true, "package": "baritone.launch.mixins", - "refmap": "mixins.client.refmap.json", + "refmap": "mixins.baritone.refmap.json", "compatibilityLevel": "JAVA_8", "verbose": false, "injectors": { From 8ef71da4816f9082dc8b8c11538ea6e68d1dc1e1 Mon Sep 17 00:00:00 2001 From: Brady Date: Thu, 23 Aug 2018 18:49:48 -0500 Subject: [PATCH 35/86] Make artifact version align with milestone version --- build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.gradle b/build.gradle index 9159f4d9..b11287d7 100755 --- a/build.gradle +++ b/build.gradle @@ -16,7 +16,7 @@ */ group 'baritone' -version '1.0' +version '1.0.0' buildscript { repositories { From 85c88e669c8d19faea0bf207f178d8d8e7b48939 Mon Sep 17 00:00:00 2001 From: Brady Date: Thu, 23 Aug 2018 19:05:54 -0500 Subject: [PATCH 36/86] Potentially fix issue in obfuscated environment --- .../java/baritone/launch/mixins/MixinNetworkManager.java | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/src/main/java/baritone/launch/mixins/MixinNetworkManager.java b/src/main/java/baritone/launch/mixins/MixinNetworkManager.java index 63e302d7..48da859f 100644 --- a/src/main/java/baritone/launch/mixins/MixinNetworkManager.java +++ b/src/main/java/baritone/launch/mixins/MixinNetworkManager.java @@ -64,8 +64,7 @@ public abstract class MixinNetworkManager { at = @At( value = "INVOKE", target = "net/minecraft/network/Packet.processPacket(Lnet/minecraft/network/INetHandler;)V" - ), - remap = false + ) ) private void preProcessPacket(ChannelHandlerContext context, Packet packet, CallbackInfo ci) { Baritone.INSTANCE.getGameEventHandler().onReceivePacket(new PacketEvent(EventState.PRE, packet)); @@ -73,8 +72,7 @@ public abstract class MixinNetworkManager { @Inject( method = "channelRead0", - at = @At("RETURN"), - remap = false + at = @At("RETURN") ) private void postProcessPacket(ChannelHandlerContext context, Packet packet, CallbackInfo ci) { if (this.channel.isOpen()) From 4de52cfec2190dcf2b0ee864dae42a3db209b488 Mon Sep 17 00:00:00 2001 From: Brady Date: Thu, 23 Aug 2018 19:18:49 -0500 Subject: [PATCH 37/86] Fix duplicate onPlayerDeath call b/c mojang is bad, fixes #85 --- .../launch/mixins/MixinGuiGameOver.java | 39 ------------------- .../mixins/MixinNetHandlerPlayClient.java | 13 +++++++ src/main/resources/mixins.baritone.json | 1 - 3 files changed, 13 insertions(+), 40 deletions(-) delete mode 100644 src/main/java/baritone/launch/mixins/MixinGuiGameOver.java diff --git a/src/main/java/baritone/launch/mixins/MixinGuiGameOver.java b/src/main/java/baritone/launch/mixins/MixinGuiGameOver.java deleted file mode 100644 index 36ded3a2..00000000 --- a/src/main/java/baritone/launch/mixins/MixinGuiGameOver.java +++ /dev/null @@ -1,39 +0,0 @@ -/* - * This file is part of Baritone. - * - * Baritone is free software: you can redistribute it and/or modify - * it under the terms of the GNU 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 General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Baritone. If not, see . - */ - -package baritone.launch.mixins; - -import baritone.Baritone; -import net.minecraft.client.gui.GuiGameOver; -import net.minecraft.util.text.ITextComponent; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.injection.At; -import org.spongepowered.asm.mixin.injection.Inject; -import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; - -/** - * @author Brady - * @since 8/22/2018 - */ -@Mixin(GuiGameOver.class) -public class MixinGuiGameOver { - - @Inject(method = "", at = @At("RETURN")) - private void onInit(ITextComponent causeOfDeathIn, CallbackInfo ci) { - Baritone.INSTANCE.getGameEventHandler().onPlayerDeath(); - } -} diff --git a/src/main/java/baritone/launch/mixins/MixinNetHandlerPlayClient.java b/src/main/java/baritone/launch/mixins/MixinNetHandlerPlayClient.java index 17d10240..2a471b25 100644 --- a/src/main/java/baritone/launch/mixins/MixinNetHandlerPlayClient.java +++ b/src/main/java/baritone/launch/mixins/MixinNetHandlerPlayClient.java @@ -22,6 +22,7 @@ import baritone.event.events.ChunkEvent; import baritone.event.events.type.EventState; import net.minecraft.client.network.NetHandlerPlayClient; import net.minecraft.network.play.server.SPacketChunkData; +import net.minecraft.network.play.server.SPacketCombatEvent; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.injection.At; import org.spongepowered.asm.mixin.injection.Inject; @@ -66,4 +67,16 @@ public class MixinNetHandlerPlayClient { ) ); } + + @Inject( + method = "handleCombatEvent", + at = @At( + value = "INVOKE", + target = "net/minecraft/client/Minecraft.displayGuiScreen(Lnet/minecraft/client/gui/GuiScreen;)V" + ) + ) + private void onPlayerDeath(SPacketCombatEvent packetIn, CallbackInfo ci) { + Baritone.INSTANCE.getGameEventHandler().onPlayerDeath(); + System.out.println("DIED"); + } } diff --git a/src/main/resources/mixins.baritone.json b/src/main/resources/mixins.baritone.json index fcbfca77..69536219 100755 --- a/src/main/resources/mixins.baritone.json +++ b/src/main/resources/mixins.baritone.json @@ -13,7 +13,6 @@ "MixinEntityRenderer", "MixinGameSettings", "MixinGuiContainer", - "MixinGuiGameOver", "MixinGuiScreen", "MixinInventoryPlayer", "MixinKeyBinding", From 42b7597cd6c8918f4ebdb094daeee73a3056df35 Mon Sep 17 00:00:00 2001 From: Brady Date: Thu, 23 Aug 2018 19:19:24 -0500 Subject: [PATCH 38/86] Remove printed debug code --- .../java/baritone/launch/mixins/MixinNetHandlerPlayClient.java | 1 - 1 file changed, 1 deletion(-) diff --git a/src/main/java/baritone/launch/mixins/MixinNetHandlerPlayClient.java b/src/main/java/baritone/launch/mixins/MixinNetHandlerPlayClient.java index 2a471b25..1af4ca6c 100644 --- a/src/main/java/baritone/launch/mixins/MixinNetHandlerPlayClient.java +++ b/src/main/java/baritone/launch/mixins/MixinNetHandlerPlayClient.java @@ -77,6 +77,5 @@ public class MixinNetHandlerPlayClient { ) private void onPlayerDeath(SPacketCombatEvent packetIn, CallbackInfo ci) { Baritone.INSTANCE.getGameEventHandler().onPlayerDeath(); - System.out.println("DIED"); } } From 18a9206058e11ff46234227f66e66bdf91e952c2 Mon Sep 17 00:00:00 2001 From: Brady Date: Thu, 23 Aug 2018 19:27:18 -0500 Subject: [PATCH 39/86] Fix comparison between incompatible types, fixes #83 --- .../java/baritone/behavior/impl/LocationTrackingBehavior.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/baritone/behavior/impl/LocationTrackingBehavior.java b/src/main/java/baritone/behavior/impl/LocationTrackingBehavior.java index 8498690e..a6128ce9 100644 --- a/src/main/java/baritone/behavior/impl/LocationTrackingBehavior.java +++ b/src/main/java/baritone/behavior/impl/LocationTrackingBehavior.java @@ -41,7 +41,7 @@ public final class LocationTrackingBehavior extends Behavior { @Override public void onBlockInteract(BlockInteractEvent event) { - if (event.getType() == BlockInteractEvent.Type.USE && BlockStateInterface.get(event.getPos()) instanceof BlockBed) { + if (event.getType() == BlockInteractEvent.Type.USE && BlockStateInterface.getBlock(event.getPos()) instanceof BlockBed) { createWaypointAtPlayer("bed", Waypoint.Tag.BED); } } From 00b0266c436b5ee4e2a466db246d9b31d89cee47 Mon Sep 17 00:00:00 2001 From: Brady Date: Thu, 23 Aug 2018 19:39:04 -0500 Subject: [PATCH 40/86] Fix duplicate waypoint issues and bad bed positions --- .../baritone/behavior/impl/LocationTrackingBehavior.java | 8 ++------ src/main/java/baritone/chunk/Waypoint.java | 4 ++-- 2 files changed, 4 insertions(+), 8 deletions(-) diff --git a/src/main/java/baritone/behavior/impl/LocationTrackingBehavior.java b/src/main/java/baritone/behavior/impl/LocationTrackingBehavior.java index a6128ce9..b4caa766 100644 --- a/src/main/java/baritone/behavior/impl/LocationTrackingBehavior.java +++ b/src/main/java/baritone/behavior/impl/LocationTrackingBehavior.java @@ -42,16 +42,12 @@ public final class LocationTrackingBehavior extends Behavior { @Override public void onBlockInteract(BlockInteractEvent event) { if (event.getType() == BlockInteractEvent.Type.USE && BlockStateInterface.getBlock(event.getPos()) instanceof BlockBed) { - createWaypointAtPlayer("bed", Waypoint.Tag.BED); + WorldProvider.INSTANCE.getCurrentWorld().waypoints.addWaypoint(new Waypoint("bed", Waypoint.Tag.BED, event.getPos())); } } @Override public void onPlayerDeath() { - createWaypointAtPlayer("death", Waypoint.Tag.DEATH); - } - - private void createWaypointAtPlayer(String name, Waypoint.Tag tag) { - WorldProvider.INSTANCE.getCurrentWorld().waypoints.addWaypoint(new Waypoint(name, tag, playerFeet())); + WorldProvider.INSTANCE.getCurrentWorld().waypoints.addWaypoint(new Waypoint("death", Waypoint.Tag.DEATH, playerFeet())); } } diff --git a/src/main/java/baritone/chunk/Waypoint.java b/src/main/java/baritone/chunk/Waypoint.java index aa800907..091c958c 100644 --- a/src/main/java/baritone/chunk/Waypoint.java +++ b/src/main/java/baritone/chunk/Waypoint.java @@ -55,12 +55,12 @@ public class Waypoint { return false; } Waypoint w = (Waypoint) o; - return name.equals(w.name) && tag == w.tag && creationTimestamp == w.creationTimestamp && location.equals(w.location); + return name.equals(w.name) && tag == w.tag && location.equals(w.location); } @Override public int hashCode() { - return name.hashCode() + tag.hashCode() + (int) creationTimestamp + location.hashCode(); //lol + return name.hashCode() + tag.hashCode() + location.hashCode(); //lol } public long creationTimestamp() { From 05ba817052cecdd605f04e8a27b24b9f12545a50 Mon Sep 17 00:00:00 2001 From: Brady Date: Thu, 23 Aug 2018 19:39:50 -0500 Subject: [PATCH 41/86] get owned idiot https://i.imgur.com/NoMJHXE.png --- src/main/java/baritone/chunk/Waypoints.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/baritone/chunk/Waypoints.java b/src/main/java/baritone/chunk/Waypoints.java index fafc102b..c1304bb8 100644 --- a/src/main/java/baritone/chunk/Waypoints.java +++ b/src/main/java/baritone/chunk/Waypoints.java @@ -75,7 +75,7 @@ public class Waypoints { } private synchronized void save(Waypoint.Tag tag) { - Path fileName = directory.resolve(tag.name().toLowerCase()); + Path fileName = directory.resolve(tag.name().toLowerCase() + ".mp4"); try ( FileOutputStream fileOut = new FileOutputStream(fileName.toFile()); BufferedOutputStream bufOut = new BufferedOutputStream(fileOut); From e778a79a7b31a6b82662e888779338c117b4a1b8 Mon Sep 17 00:00:00 2001 From: Brady Date: Thu, 23 Aug 2018 19:44:30 -0500 Subject: [PATCH 42/86] Loading an mp4? nah. Saving one? yep. --- src/main/java/baritone/chunk/Waypoints.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/baritone/chunk/Waypoints.java b/src/main/java/baritone/chunk/Waypoints.java index c1304bb8..702216bd 100644 --- a/src/main/java/baritone/chunk/Waypoints.java +++ b/src/main/java/baritone/chunk/Waypoints.java @@ -54,7 +54,7 @@ public class Waypoints { private synchronized void load(Waypoint.Tag tag) { waypoints.put(tag, new HashSet<>()); - Path fileName = directory.resolve(tag.name().toLowerCase()); + Path fileName = directory.resolve(tag.name().toLowerCase() + ".mp4"); if (!Files.exists(fileName)) return; From c3009b46a8722396d9f45c27f0cd88001f09f12e Mon Sep 17 00:00:00 2001 From: Brady Date: Thu, 23 Aug 2018 20:09:40 -0500 Subject: [PATCH 43/86] End of file magic values are bad change my mind --- src/main/java/baritone/chunk/CachedRegion.java | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/src/main/java/baritone/chunk/CachedRegion.java b/src/main/java/baritone/chunk/CachedRegion.java index 385a206c..514d1b23 100644 --- a/src/main/java/baritone/chunk/CachedRegion.java +++ b/src/main/java/baritone/chunk/CachedRegion.java @@ -160,7 +160,6 @@ public final class CachedRegion implements IBlockTypeAccess { } } } - out.writeInt(~CACHED_REGION_MAGIC); } hasUnsavedChanges = false; System.out.println("Saved region successfully"); @@ -231,6 +230,8 @@ public final class CachedRegion implements IBlockTypeAccess { for (int x = 0; x < 32; x++) { if (tmpCached[x][z] != null) { // 16 * 16 * 256 = 65536 so a short is enough + // ^ haha jokes on leijurv, java doesn't have unsigned types so that isn't correct + // also ur gay if u have more than 32767 special blocks in a chunk short numSpecialBlockTypes = in.readShort(); for (int i = 0; i < numSpecialBlockTypes; i++) { String blockName = in.readUTF(); @@ -251,10 +252,6 @@ public final class CachedRegion implements IBlockTypeAccess { } } } - int fileEndMagic = in.readInt(); - if (fileEndMagic != ~magic) { - throw new IOException("Bad end of file magic"); - } // only if the entire file was uncorrupted do we actually set the chunks for (int x = 0; x < 32; x++) { for (int z = 0; z < 32; z++) { From 6ce0f40451170eaab0824fb527d073780fe577ef Mon Sep 17 00:00:00 2001 From: Brady Date: Thu, 23 Aug 2018 20:16:40 -0500 Subject: [PATCH 44/86] Waypoint magic --- src/main/java/baritone/chunk/Waypoints.java | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/src/main/java/baritone/chunk/Waypoints.java b/src/main/java/baritone/chunk/Waypoints.java index 702216bd..d75ff733 100644 --- a/src/main/java/baritone/chunk/Waypoints.java +++ b/src/main/java/baritone/chunk/Waypoints.java @@ -30,6 +30,12 @@ import java.util.*; * @author leijurv */ public class Waypoints { + + /** + * Magic value to detect invalid waypoint files + */ + private static final long WAYPOINT_MAGIC_VALUE = 121977993584L; // good value + private final Path directory; private final Map> waypoints; @@ -63,7 +69,13 @@ public class Waypoints { BufferedInputStream bufIn = new BufferedInputStream(fileIn); DataInputStream in = new DataInputStream(bufIn) ) { - while (true) { + long magic = in.readLong(); + if (magic != WAYPOINT_MAGIC_VALUE) { + throw new IOException("Bad magic value " + magic); + } + + long length = in.readLong(); // Yes I want 9,223,372,036,854,775,807 waypoints, do you not? + while (length-- > 0) { String name = in.readUTF(); long creationTimestamp = in.readLong(); int x = in.readInt(); @@ -81,6 +93,8 @@ public class Waypoints { BufferedOutputStream bufOut = new BufferedOutputStream(fileOut); DataOutputStream out = new DataOutputStream(bufOut) ) { + out.writeLong(WAYPOINT_MAGIC_VALUE); + out.writeLong(waypoints.get(tag).size()); for (Waypoint waypoint : waypoints.get(tag)) { out.writeUTF(waypoint.name); out.writeLong(waypoint.creationTimestamp()); From c8de4a4e00aee356d8cc73fce2fedcef47dfd9f2 Mon Sep 17 00:00:00 2001 From: Brady Date: Thu, 23 Aug 2018 20:43:37 -0500 Subject: [PATCH 45/86] Fix coloring across multiple lines --- src/main/java/baritone/utils/Helper.java | 20 +++++++------------- 1 file changed, 7 insertions(+), 13 deletions(-) diff --git a/src/main/java/baritone/utils/Helper.java b/src/main/java/baritone/utils/Helper.java index c637e48f..c973b1ca 100755 --- a/src/main/java/baritone/utils/Helper.java +++ b/src/main/java/baritone/utils/Helper.java @@ -20,16 +20,12 @@ package baritone.utils; import baritone.Baritone; import net.minecraft.client.Minecraft; import net.minecraft.client.entity.EntityPlayerSP; -import net.minecraft.client.gui.GuiNewChat; -import net.minecraft.client.gui.GuiUtilRenderComponents; import net.minecraft.client.multiplayer.WorldClient; import net.minecraft.util.math.BlockPos; -import net.minecraft.util.math.MathHelper; import net.minecraft.util.math.Vec3d; import net.minecraft.util.text.ITextComponent; import net.minecraft.util.text.TextComponentString; - -import java.util.List; +import net.minecraft.util.text.TextFormatting; /** * @author Brady @@ -37,6 +33,8 @@ import java.util.List; */ public interface Helper { + ITextComponent MESSAGE_PREFIX = new TextComponentString("§5[§dBaritone§5]§7"); + Minecraft mc = Minecraft.getMinecraft(); default EntityPlayerSP player() { @@ -73,14 +71,10 @@ public interface Helper { System.out.println(message); return; } - GuiNewChat gui = mc.ingameGUI.getChatGUI(); - int normalMaxWidth = MathHelper.floor((float) gui.getChatWidth() / gui.getChatScale()); - int widthWithStyleFormat = normalMaxWidth - 2; - List list = GuiUtilRenderComponents.splitText(new TextComponentString("§5[§dBaritone§5]§7 " + message), widthWithStyleFormat, - this.mc.fontRenderer, false, true); - for (ITextComponent component : list) { - gui.printChatMessage(new TextComponentString("§7" + component.getUnformattedText())); - } + ITextComponent component = MESSAGE_PREFIX.createCopy(); + component.getStyle().setColor(TextFormatting.GRAY); + component.appendSibling(new TextComponentString(" " + message)); + mc.ingameGUI.getChatGUI().printChatMessage(component); } } From 93de55318fabb58b53070cdf53079a729e3daa0a Mon Sep 17 00:00:00 2001 From: Brady Date: Thu, 23 Aug 2018 20:57:32 -0500 Subject: [PATCH 46/86] Force # command prefix --- src/main/java/baritone/utils/ExampleBaritoneControl.java | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/main/java/baritone/utils/ExampleBaritoneControl.java b/src/main/java/baritone/utils/ExampleBaritoneControl.java index fbd801f3..063c939c 100644 --- a/src/main/java/baritone/utils/ExampleBaritoneControl.java +++ b/src/main/java/baritone/utils/ExampleBaritoneControl.java @@ -55,9 +55,10 @@ public class ExampleBaritoneControl extends Behavior { return; } String msg = event.getMessage(); - if (msg.startsWith("/")) { - msg = msg.substring(1); - } + if (!msg.startsWith("#")) + return; + + msg = msg.substring(1); if (msg.toLowerCase().startsWith("goal")) { event.cancel(); String[] params = msg.toLowerCase().substring(4).trim().split(" "); From 71ce9cd901d61bef12bea6bc7289f47b05e99c28 Mon Sep 17 00:00:00 2001 From: Brady Date: Thu, 23 Aug 2018 21:01:35 -0500 Subject: [PATCH 47/86] Make the prefix optional --- src/main/java/baritone/Settings.java | 5 +++++ src/main/java/baritone/utils/ExampleBaritoneControl.java | 2 +- 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/src/main/java/baritone/Settings.java b/src/main/java/baritone/Settings.java index 57e0543b..3b64e70a 100644 --- a/src/main/java/baritone/Settings.java +++ b/src/main/java/baritone/Settings.java @@ -241,6 +241,11 @@ public class Settings { */ public Setting pathThroughCachedOnly = new Setting<>(false); + /** + * Whether or not to use the "#" command prefix + */ + public Setting prefix = new Setting<>(false); + public final Map> byLowerName; public final List> allSettings; diff --git a/src/main/java/baritone/utils/ExampleBaritoneControl.java b/src/main/java/baritone/utils/ExampleBaritoneControl.java index 063c939c..52b142af 100644 --- a/src/main/java/baritone/utils/ExampleBaritoneControl.java +++ b/src/main/java/baritone/utils/ExampleBaritoneControl.java @@ -55,7 +55,7 @@ public class ExampleBaritoneControl extends Behavior { return; } String msg = event.getMessage(); - if (!msg.startsWith("#")) + if (Baritone.settings().prefix.get() && !msg.startsWith("#")) return; msg = msg.substring(1); From 830c90dd971138923b8f0f10a868918bf9cb17b0 Mon Sep 17 00:00:00 2001 From: Brady Date: Thu, 23 Aug 2018 21:26:28 -0500 Subject: [PATCH 48/86] Use relative path to main game dir as comparison, fixes #86 --- src/main/java/baritone/chunk/WorldProvider.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main/java/baritone/chunk/WorldProvider.java b/src/main/java/baritone/chunk/WorldProvider.java index 9cb60c9d..b444725a 100644 --- a/src/main/java/baritone/chunk/WorldProvider.java +++ b/src/main/java/baritone/chunk/WorldProvider.java @@ -61,7 +61,8 @@ public enum WorldProvider implements Helper { IAnvilChunkLoader loader = (IAnvilChunkLoader) provider.getChunkLoader(); directory = loader.getChunkSaveLocation(); - if (!directory.getParentFile().getName().equals("saves")) { + // In the case of any dimension that isn't the overworld, we'll see a number other than 2 (likely 3) + if (directory.toPath().relativize(mc.gameDir.toPath()).getNameCount() != 2) { // subdirectory of the main save directory for this world directory = directory.getParentFile(); } From a18ff092d84e9d66cb40f0df1865e9e59217a6fb Mon Sep 17 00:00:00 2001 From: leijurv Date: Thu, 23 Aug 2018 19:57:49 -0700 Subject: [PATCH 49/86] finally fixed MovementAscend --- .../movement/movements/MovementAscend.java | 38 +++++++++++++++---- 1 file changed, 31 insertions(+), 7 deletions(-) diff --git a/src/main/java/baritone/pathing/movement/movements/MovementAscend.java b/src/main/java/baritone/pathing/movement/movements/MovementAscend.java index 596a6d86..9b664df6 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementAscend.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementAscend.java @@ -164,17 +164,41 @@ public class MovementAscend extends Movement { return state.setStatus(MovementStatus.UNREACHABLE); } MovementHelper.moveTowards(state, dest); - state.setInput(InputOverrideHandler.Input.JUMP, true); - // TODO check if the below actually helps or hurts, it's weird - //double flatDistToNext = Math.abs(to.getX() - from.getX()) * Math.abs((to.getX() + 0.5D) - thePlayer.posX) + Math.abs(to.getZ() - from.getZ()) * Math.abs((to.getZ() + 0.5D) - thePlayer.posZ); - //boolean pointingInCorrectDirection = MovementManager.moveTowardsBlock(to); - //MovementManager.jumping = flatDistToNext < 1.2 && pointingInCorrectDirection; + if (headBonkClear()) { + state.setInput(InputOverrideHandler.Input.JUMP, true); + return state; + } + + int xAxis = Math.abs(src.getX() - dest.getX()); // either 0 or 1 + int zAxis = Math.abs(src.getZ() - dest.getZ()); // either 0 or 1 + double flatDistToNext = xAxis * Math.abs((dest.getX() + 0.5D) - player().posX) + zAxis * Math.abs((dest.getZ() + 0.5D) - player().posZ); + + double sideDist = zAxis * Math.abs((dest.getX()+0.5D) - player().posX) + xAxis * Math.abs((dest.getZ()+0.5D) - player().posZ); + System.out.println(flatDistToNext+" "+sideDist); + if (flatDistToNext > 1.2) { + return state; + } + + if (sideDist > 0.2) { + return state; + } //once we are pointing the right way and moving, start jumping //this is slightly more efficient because otherwise we might start jumping before moving, and fall down without moving onto the block we want to jump onto //also wait until we are close enough, because we might jump and hit our head on an adjacent block - //return Baritone.playerFeet.equals(to); - + state.setInput(InputOverrideHandler.Input.JUMP, true); return state; } + + private boolean headBonkClear() { + BlockPos startUp = src.up(2); + for (int i = 0; i < 4; i++) { + BlockPos check = startUp.offset(EnumFacing.byHorizontalIndex(i)); + if (!MovementHelper.canWalkThrough(check)) { + // we might bonk our head + return false; + } + } + return true; + } } From bf37d50d6f6af693d1b9761ea0c0cc961fded785 Mon Sep 17 00:00:00 2001 From: leijurv Date: Thu, 23 Aug 2018 19:58:00 -0700 Subject: [PATCH 50/86] fix mixin json file name --- src/main/resources/mixins.baritone.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/resources/mixins.baritone.json b/src/main/resources/mixins.baritone.json index 69536219..523662db 100755 --- a/src/main/resources/mixins.baritone.json +++ b/src/main/resources/mixins.baritone.json @@ -1,7 +1,7 @@ { "required": true, "package": "baritone.launch.mixins", - "refmap": "mixins.baritone.refmap.json", + "refmap": "mixin.refmap.json", "compatibilityLevel": "JAVA_8", "verbose": false, "injectors": { From 6631f9c80f2eded62953441379f341f557e08868 Mon Sep 17 00:00:00 2001 From: leijurv Date: Thu, 23 Aug 2018 20:04:23 -0700 Subject: [PATCH 51/86] reformat --- .../baritone/pathing/movement/movements/MovementAscend.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/baritone/pathing/movement/movements/MovementAscend.java b/src/main/java/baritone/pathing/movement/movements/MovementAscend.java index 9b664df6..020f4811 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementAscend.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementAscend.java @@ -174,8 +174,8 @@ public class MovementAscend extends Movement { int zAxis = Math.abs(src.getZ() - dest.getZ()); // either 0 or 1 double flatDistToNext = xAxis * Math.abs((dest.getX() + 0.5D) - player().posX) + zAxis * Math.abs((dest.getZ() + 0.5D) - player().posZ); - double sideDist = zAxis * Math.abs((dest.getX()+0.5D) - player().posX) + xAxis * Math.abs((dest.getZ()+0.5D) - player().posZ); - System.out.println(flatDistToNext+" "+sideDist); + double sideDist = zAxis * Math.abs((dest.getX() + 0.5D) - player().posX) + xAxis * Math.abs((dest.getZ() + 0.5D) - player().posZ); + System.out.println(flatDistToNext + " " + sideDist); if (flatDistToNext > 1.2) { return state; } From 37d4e7b178856e15ea99b8a89fbe4ac9500fbaf3 Mon Sep 17 00:00:00 2001 From: leijurv Date: Thu, 23 Aug 2018 20:12:36 -0700 Subject: [PATCH 52/86] fixed prefix logic --- .../java/baritone/utils/ExampleBaritoneControl.java | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/main/java/baritone/utils/ExampleBaritoneControl.java b/src/main/java/baritone/utils/ExampleBaritoneControl.java index 52b142af..c79ccab9 100644 --- a/src/main/java/baritone/utils/ExampleBaritoneControl.java +++ b/src/main/java/baritone/utils/ExampleBaritoneControl.java @@ -55,10 +55,12 @@ public class ExampleBaritoneControl extends Behavior { return; } String msg = event.getMessage(); - if (Baritone.settings().prefix.get() && !msg.startsWith("#")) - return; - - msg = msg.substring(1); + if (Baritone.settings().prefix.get()) { + if (!msg.startsWith("#")) { + return; + } + msg = msg.substring(1); + } if (msg.toLowerCase().startsWith("goal")) { event.cancel(); String[] params = msg.toLowerCase().substring(4).trim().split(" "); From 5b60d01c1189103a4ed64a37d286fae719345270 Mon Sep 17 00:00:00 2001 From: leijurv Date: Fri, 24 Aug 2018 08:42:54 -0700 Subject: [PATCH 53/86] peace and quiet --- .../baritone/pathing/movement/movements/MovementAscend.java | 2 +- src/main/java/baritone/utils/InputOverrideHandler.java | 2 -- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/src/main/java/baritone/pathing/movement/movements/MovementAscend.java b/src/main/java/baritone/pathing/movement/movements/MovementAscend.java index 020f4811..bbaca073 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementAscend.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementAscend.java @@ -175,7 +175,7 @@ public class MovementAscend extends Movement { double flatDistToNext = xAxis * Math.abs((dest.getX() + 0.5D) - player().posX) + zAxis * Math.abs((dest.getZ() + 0.5D) - player().posZ); double sideDist = zAxis * Math.abs((dest.getX() + 0.5D) - player().posX) + xAxis * Math.abs((dest.getZ() + 0.5D) - player().posZ); - System.out.println(flatDistToNext + " " + sideDist); + //System.out.println(flatDistToNext + " " + sideDist); if (flatDistToNext > 1.2) { return state; } diff --git a/src/main/java/baritone/utils/InputOverrideHandler.java b/src/main/java/baritone/utils/InputOverrideHandler.java index 18426548..9860e2e1 100755 --- a/src/main/java/baritone/utils/InputOverrideHandler.java +++ b/src/main/java/baritone/utils/InputOverrideHandler.java @@ -84,8 +84,6 @@ public final class InputOverrideHandler implements Helper { * @param forced Whether or not the state is being forced */ public final void setInputForceState(Input input, boolean forced) { - if (!forced) - System.out.println(input); inputForceStateMap.put(input.getKeyBinding(), forced); } From cbec60472b3de4686628b47d162fccd2deacf6be Mon Sep 17 00:00:00 2001 From: Brady Date: Fri, 24 Aug 2018 13:54:01 -0500 Subject: [PATCH 54/86] Replace anonymous thread in PathingBehavior with lambda body --- src/main/java/baritone/behavior/impl/PathingBehavior.java | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/src/main/java/baritone/behavior/impl/PathingBehavior.java b/src/main/java/baritone/behavior/impl/PathingBehavior.java index de322b98..2ab0d804 100644 --- a/src/main/java/baritone/behavior/impl/PathingBehavior.java +++ b/src/main/java/baritone/behavior/impl/PathingBehavior.java @@ -61,11 +61,7 @@ public class PathingBehavior extends Behavior { private boolean lastAutoJump; private void dispatchPathEvent(PathEvent event) { - new Thread() { - public void run() { - Baritone.INSTANCE.getGameEventHandler().onPathEvent(event); - } - }.start(); + new Thread(() -> Baritone.INSTANCE.getGameEventHandler().onPathEvent(event)).start(); } @Override From c51a65488af5b3ae19ab0c28806697e928206fad Mon Sep 17 00:00:00 2001 From: Leijurv Date: Fri, 24 Aug 2018 14:24:09 -0700 Subject: [PATCH 55/86] lol what --- src/main/java/baritone/chunk/CachedWorld.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/baritone/chunk/CachedWorld.java b/src/main/java/baritone/chunk/CachedWorld.java index 7c86db0f..b24857de 100644 --- a/src/main/java/baritone/chunk/CachedWorld.java +++ b/src/main/java/baritone/chunk/CachedWorld.java @@ -110,7 +110,7 @@ public final class CachedWorld implements IBlockTypeAccess { while (searchRadius <= maxRegionDistanceSq) { for (int xoff = -searchRadius; xoff <= searchRadius; xoff++) { for (int zoff = -searchRadius; zoff <= searchRadius; zoff++) { - double distance = xoff * xoff + zoff * zoff; + int distance = xoff * xoff + zoff * zoff; if (distance != searchRadius) { continue; } From d14d0e131bbd84e18c92ea278024a491f5d1eb4b Mon Sep 17 00:00:00 2001 From: Brady Date: Sat, 25 Aug 2018 00:24:19 -0500 Subject: [PATCH 56/86] Better comment explaining new folder depth check --- src/main/java/baritone/chunk/WorldProvider.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/baritone/chunk/WorldProvider.java b/src/main/java/baritone/chunk/WorldProvider.java index b444725a..709ddff8 100644 --- a/src/main/java/baritone/chunk/WorldProvider.java +++ b/src/main/java/baritone/chunk/WorldProvider.java @@ -61,7 +61,7 @@ public enum WorldProvider implements Helper { IAnvilChunkLoader loader = (IAnvilChunkLoader) provider.getChunkLoader(); directory = loader.getChunkSaveLocation(); - // In the case of any dimension that isn't the overworld, we'll see a number other than 2 (likely 3) + // Gets the "depth" of this directory relative the the game's run directory, 2 is the location of the world if (directory.toPath().relativize(mc.gameDir.toPath()).getNameCount() != 2) { // subdirectory of the main save directory for this world directory = directory.getParentFile(); @@ -79,7 +79,7 @@ public enum WorldProvider implements Helper { try (FileOutputStream out = new FileOutputStream(new File(readme, "readme.txt"))) { // good thing we have a readme out.write("https://github.com/cabaletta/baritone\n".getBytes()); - } catch (IOException ex) {} + } catch (IOException ignored) {} directory = new File(directory, "DIM" + dimensionID); Path dir = directory.toPath(); From 8ff89e7400d35445a419411587add024fbaef3fd Mon Sep 17 00:00:00 2001 From: Brady Date: Sat, 25 Aug 2018 01:38:53 -0500 Subject: [PATCH 57/86] Block break simulation instead of input override for breaking, fixes #74 --- .../launch/mixins/MixinMinecraft.java | 17 ------ .../baritone/pathing/movement/Movement.java | 22 ++++++++ .../java/baritone/utils/BlockBreakHelper.java | 52 +++++++++++++++++++ 3 files changed, 74 insertions(+), 17 deletions(-) create mode 100644 src/main/java/baritone/utils/BlockBreakHelper.java diff --git a/src/main/java/baritone/launch/mixins/MixinMinecraft.java b/src/main/java/baritone/launch/mixins/MixinMinecraft.java index 2bb04ef8..3d0b6619 100755 --- a/src/main/java/baritone/launch/mixins/MixinMinecraft.java +++ b/src/main/java/baritone/launch/mixins/MixinMinecraft.java @@ -102,23 +102,6 @@ public class MixinMinecraft { Baritone.INSTANCE.getGameEventHandler().onProcessKeyBinds(); } - @Redirect( - method = { - "setIngameFocus", - "runTick" - }, - at = @At( - value = "FIELD", - opcode = Opcodes.PUTFIELD, - target = "net/minecraft/client/Minecraft.leftClickCounter:I", - ordinal = 0 - ) - ) - private void setLeftClickCounter(Minecraft mc, int value) { - if (!Baritone.INSTANCE.isInitialized() || !Baritone.INSTANCE.getInputOverrideHandler().isInputForcedDown(mc.gameSettings.keyBindAttack)) - this.leftClickCounter = value; - } - @Inject( method = "loadWorld(Lnet/minecraft/client/multiplayer/WorldClient;Ljava/lang/String;)V", at = @At("HEAD") diff --git a/src/main/java/baritone/pathing/movement/Movement.java b/src/main/java/baritone/pathing/movement/Movement.java index 99c17d8c..73a42121 100644 --- a/src/main/java/baritone/pathing/movement/Movement.java +++ b/src/main/java/baritone/pathing/movement/Movement.java @@ -29,6 +29,7 @@ import net.minecraft.block.Block; import net.minecraft.block.BlockLadder; import net.minecraft.block.BlockVine; import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.RayTraceResult; import net.minecraft.util.math.Vec3d; import java.util.ArrayList; @@ -54,6 +55,8 @@ public abstract class Movement implements Helper, MovementHelper { */ protected final BlockPos[] positionsToPlace; + private boolean didBreakLastTick; + private Double cost; protected Movement(BlockPos src, BlockPos dest, BlockPos[] toBreak, BlockPos[] toPlace) { @@ -114,10 +117,29 @@ public abstract class Movement implements Helper, MovementHelper { // TODO: calculate movement inputs from latestState.getGoal().position // latestState.getTarget().position.ifPresent(null); NULL CONSUMER REALLY SHOULDN'T BE THE FINAL THING YOU SHOULD REALLY REPLACE THIS WITH ALMOST ACTUALLY ANYTHING ELSE JUST PLEASE DON'T LEAVE IT AS IT IS THANK YOU KANYE + + this.didBreakLastTick = false; + latestState.getInputStates().forEach((input, forced) -> { + RayTraceResult trace = mc.objectMouseOver; + boolean isBlockTrace = trace != null && trace.typeOfHit == RayTraceResult.Type.BLOCK; + boolean isLeftClick = forced && input == Input.CLICK_LEFT; + + // If we're forcing left click, we're in a gui screen, and we're looking + // at a block, break the block without a direct game input manipulation. + if (mc.currentScreen != null && isLeftClick && isBlockTrace) { + BlockBreakHelper.tryBreakBlock(trace.getBlockPos(), trace.sideHit); + this.didBreakLastTick = true; + return; + } + Baritone.INSTANCE.getInputOverrideHandler().setInputForceState(input, forced); }); latestState.getInputStates().replaceAll((input, forced) -> false); + + if (!this.didBreakLastTick) + BlockBreakHelper.stopBreakingBlock(); + currentState = latestState; if (isFinished()) diff --git a/src/main/java/baritone/utils/BlockBreakHelper.java b/src/main/java/baritone/utils/BlockBreakHelper.java new file mode 100644 index 00000000..8c224a2b --- /dev/null +++ b/src/main/java/baritone/utils/BlockBreakHelper.java @@ -0,0 +1,52 @@ +/* + * This file is part of Baritone. + * + * Baritone is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Baritone. If not, see . + */ + +package baritone.utils; + +import net.minecraft.util.EnumFacing; +import net.minecraft.util.EnumHand; +import net.minecraft.util.math.BlockPos; + +/** + * @author Brady + * @since 8/25/2018 + */ +public final class BlockBreakHelper implements Helper { + + private BlockBreakHelper() {} + + /** + * The last block that we tried to break, if this value changes + * between attempts, then we re-initialize the breaking process. + */ + private static BlockPos lastBlock; + + public static void tryBreakBlock(BlockPos pos, EnumFacing side) { + if (!pos.equals(lastBlock)) { + mc.playerController.clickBlock(pos, side); + } + if (mc.playerController.onPlayerDamageBlock(pos, side)) { + mc.player.swingArm(EnumHand.MAIN_HAND); + } + lastBlock = pos; + } + + public static void stopBreakingBlock() { + mc.playerController.resetBlockRemoving(); + lastBlock = null; + } +} From 21c1fc09e7c15fc1cc9e986fbf2c6bc62568419d Mon Sep 17 00:00:00 2001 From: Brady Date: Sat, 25 Aug 2018 02:10:31 -0500 Subject: [PATCH 58/86] Added newlines after every declaration in PathEvent enum --- src/main/java/baritone/event/events/PathEvent.java | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/src/main/java/baritone/event/events/PathEvent.java b/src/main/java/baritone/event/events/PathEvent.java index 0b110899..53892058 100644 --- a/src/main/java/baritone/event/events/PathEvent.java +++ b/src/main/java/baritone/event/events/PathEvent.java @@ -18,5 +18,15 @@ package baritone.event.events; public enum PathEvent { - CALC_STARTED, CALC_FINISHED_NOW_EXECUTING, CALC_FAILED, NEXT_SEGMENT_CALC_STARTED, NEXT_SEGMENT_CALC_FINISHED, CONTINUING_ONTO_PLANNED_NEXT, SPLICING_ONTO_NEXT_EARLY, AT_GOAL, PATH_FINISHED_NEXT_STILL_CALCULATING, NEXT_CALC_FAILED, DISCARD_NEXT; + CALC_STARTED, + CALC_FINISHED_NOW_EXECUTING, + CALC_FAILED, + NEXT_SEGMENT_CALC_STARTED, + NEXT_SEGMENT_CALC_FINISHED, + CONTINUING_ONTO_PLANNED_NEXT, + SPLICING_ONTO_NEXT_EARLY, + AT_GOAL, + PATH_FINISHED_NEXT_STILL_CALCULATING, + NEXT_CALC_FAILED, + DISCARD_NEXT } From db6453fae09a60417bdd9738f2afa66d6fd7f850 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sat, 25 Aug 2018 07:07:09 -0700 Subject: [PATCH 59/86] accuracy --- src/main/java/baritone/pathing/goals/GoalYLevel.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/baritone/pathing/goals/GoalYLevel.java b/src/main/java/baritone/pathing/goals/GoalYLevel.java index 7a437f9d..89cef250 100644 --- a/src/main/java/baritone/pathing/goals/GoalYLevel.java +++ b/src/main/java/baritone/pathing/goals/GoalYLevel.java @@ -48,7 +48,7 @@ public class GoalYLevel implements Goal { } if (pos.getY() < level) { // need to ascend - return (level - pos.getY()) * JUMP_ONE_BLOCK_COST * 0.9; + return (level - pos.getY()) * JUMP_ONE_BLOCK_COST; } return 0; } From 342bb8616c66c7e213e3862bf9fa3bf773c1a8e0 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sat, 25 Aug 2018 08:44:33 -0700 Subject: [PATCH 60/86] fix passable and replacable checks for snow in cached chunks, fixes #87 --- src/main/java/baritone/chunk/ChunkPacker.java | 1 - .../pathing/movement/MovementHelper.java | 39 +++++++++++++++++-- .../movement/movements/MovementAscend.java | 5 +-- .../movement/movements/MovementTraverse.java | 2 +- 4 files changed, 39 insertions(+), 8 deletions(-) diff --git a/src/main/java/baritone/chunk/ChunkPacker.java b/src/main/java/baritone/chunk/ChunkPacker.java index 7cc569a7..845c2d99 100644 --- a/src/main/java/baritone/chunk/ChunkPacker.java +++ b/src/main/java/baritone/chunk/ChunkPacker.java @@ -112,7 +112,6 @@ public final class ChunkPacker implements Helper { if (MovementHelper.avoidWalkingInto(block)) { return PathingBlockType.AVOID; } - // We used to do an AABB check here // however, this failed in the nether when you were near a nether fortress // because fences check their adjacent blocks in the world for their fence connection status to determine AABB shape diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java index 26a026d0..ed52f8cc 100644 --- a/src/main/java/baritone/pathing/movement/MovementHelper.java +++ b/src/main/java/baritone/pathing/movement/MovementHelper.java @@ -33,6 +33,7 @@ import net.minecraft.item.ItemStack; import net.minecraft.util.NonNullList; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.RayTraceResult; +import net.minecraft.world.chunk.EmptyChunk; import java.util.Optional; @@ -75,16 +76,48 @@ public interface MovementHelper extends ActionCosts, Helper { || block instanceof BlockEndPortal) {//you can't actually walk through a lilypad from the side, and you shouldn't walk through fire return false; } + if (block instanceof BlockDoor) { + if (block == Blocks.IRON_DOOR) { + return false; + } + return true; // we can just open the door + } + if (block instanceof BlockSnow || block instanceof BlockFenceGate || block instanceof BlockTrapDoor) { + // we've already checked doors + // so the only remaining dynamic isPassables are snow, fence gate, and trapdoor + // 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 (mc.world.getChunk(pos) instanceof EmptyChunk) { + return true; + } + } IBlockState up = BlockStateInterface.get(pos.up()); if (BlockStateInterface.isFlowing(state) || up.getBlock() instanceof BlockLiquid || up.getBlock() instanceof BlockLilyPad) { return false; // Don't walk through flowing liquids } - if (block instanceof BlockDoor && !Blocks.IRON_DOOR.equals(block)) { - return true; // we can just open the door - } return block.isPassable(mc.world, pos); } + static boolean isReplacable(BlockPos pos, IBlockState state) { + // for MovementTraverse and MovementAscend + // block double plant defaults to true when the block doesn't match, so don't need to check that case + // all other overrides just return true or false + // the only case to deal with is snow + /* + * public boolean isReplaceable(IBlockAccess worldIn, BlockPos pos) + * { + * return ((Integer)worldIn.getBlockState(pos).getValue(LAYERS)).intValue() == 1; + * } + */ + if (state.getBlock() instanceof BlockSnow) { + // as before, default to true (mostly because it would otherwise make long distance pathing through snowy biomes impossible) + if (mc.world.getChunk(pos) instanceof EmptyChunk) { + return true; + } + } + return state.getBlock().isReplaceable(mc.world, pos); + } + static boolean isDoorPassable(BlockPos doorPos, BlockPos playerPos) { IBlockState door = BlockStateInterface.get(doorPos); if (!(door.getBlock() instanceof BlockDoor)) { diff --git a/src/main/java/baritone/pathing/movement/movements/MovementAscend.java b/src/main/java/baritone/pathing/movement/movements/MovementAscend.java index bbaca073..956d7091 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementAscend.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementAscend.java @@ -74,11 +74,10 @@ public class MovementAscend extends Movement { protected double calculateCost(CalculationContext context) { IBlockState toPlace = BlockStateInterface.get(positionsToPlace[0]); if (!MovementHelper.canWalkOn(positionsToPlace[0], toPlace)) { - if (!BlockStateInterface.isAir(toPlace) && !BlockStateInterface.isWater(toPlace.getBlock())) { - // TODO replace this check with isReplacable or similar + if (!context.hasThrowaway()) { return COST_INF; } - if (!context.hasThrowaway()) { + if (!BlockStateInterface.isAir(toPlace) && !BlockStateInterface.isWater(toPlace.getBlock()) && !MovementHelper.isReplacable(positionsToPlace[0], toPlace)) { return COST_INF; } for (BlockPos against1 : against) { diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java index 51429db4..aac418a6 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java @@ -107,7 +107,7 @@ public class MovementTraverse extends Movement { return COST_INF; } IBlockState pp0 = BlockStateInterface.get(positionsToPlace[0]); - if (pp0.getBlock().equals(Blocks.AIR) || (!BlockStateInterface.isWater(pp0.getBlock()) && pp0.getBlock().isReplaceable(Minecraft.getMinecraft().world, positionsToPlace[0]))) { + if (pp0.getBlock().equals(Blocks.AIR) || (!BlockStateInterface.isWater(pp0.getBlock()) && MovementHelper.isReplacable(positionsToPlace[0], pp0))) { if (!context.hasThrowaway()) { return COST_INF; } From 871dc98accc6052484400c15f61a484425b28c20 Mon Sep 17 00:00:00 2001 From: Brady Date: Sat, 25 Aug 2018 14:22:39 -0500 Subject: [PATCH 61/86] Change SOLID pathing types based on dimension, fixes #88 --- src/main/java/baritone/chunk/ChunkPacker.java | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/src/main/java/baritone/chunk/ChunkPacker.java b/src/main/java/baritone/chunk/ChunkPacker.java index 845c2d99..e205d7f8 100644 --- a/src/main/java/baritone/chunk/ChunkPacker.java +++ b/src/main/java/baritone/chunk/ChunkPacker.java @@ -133,7 +133,18 @@ public final class ChunkPacker implements Helper { case AVOID: return Blocks.LAVA.getDefaultState(); case SOLID: - return Blocks.OBSIDIAN.getDefaultState(); + // Dimension solid types + switch (mc.player.dimension) { + case -1: + return Blocks.NETHERRACK.getDefaultState(); + case 0: + return Blocks.STONE.getDefaultState(); + case 1: + return Blocks.END_STONE.getDefaultState(); + } + + // The fallback solid type + return Blocks.STONE.getDefaultState(); } } return null; From fdf11f9d76c3bed0fe1704c9843b09d62112d122 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sat, 25 Aug 2018 15:09:47 -0700 Subject: [PATCH 62/86] invert goal to run away --- .../behavior/impl/PathingBehavior.java | 4 ++++ .../utils/ExampleBaritoneControl.java | 22 +++++++++++++++++++ 2 files changed, 26 insertions(+) diff --git a/src/main/java/baritone/behavior/impl/PathingBehavior.java b/src/main/java/baritone/behavior/impl/PathingBehavior.java index 2ab0d804..83a479a4 100644 --- a/src/main/java/baritone/behavior/impl/PathingBehavior.java +++ b/src/main/java/baritone/behavior/impl/PathingBehavior.java @@ -176,6 +176,10 @@ public class PathingBehavior extends Behavior { this.goal = goal; } + public Goal getGoal() { + return goal; + } + public PathExecutor getCurrent() { return current; } diff --git a/src/main/java/baritone/utils/ExampleBaritoneControl.java b/src/main/java/baritone/utils/ExampleBaritoneControl.java index c79ccab9..58e93658 100644 --- a/src/main/java/baritone/utils/ExampleBaritoneControl.java +++ b/src/main/java/baritone/utils/ExampleBaritoneControl.java @@ -109,6 +109,28 @@ public class ExampleBaritoneControl extends Behavior { displayChatMessageRaw("ok canceled"); return; } + if (msg.toLowerCase().equals("invert")) { + Goal goal = PathingBehavior.INSTANCE.getGoal(); + BlockPos runAwayFrom; + if (goal instanceof GoalXZ) { + runAwayFrom = new BlockPos(((GoalXZ) goal).getX(), 0, ((GoalXZ) goal).getZ()); + } else if (goal instanceof GoalBlock) { + runAwayFrom = ((GoalBlock) goal).getGoalPos(); + } else { + displayChatMessageRaw("Goal must be GoalXZ or GoalBlock to invert"); + displayChatMessageRaw("Inverting goal of player feet"); + runAwayFrom = playerFeet(); + } + PathingBehavior.INSTANCE.setGoal(new GoalRunAway(1, runAwayFrom) { + @Override + public boolean isInGoal(BlockPos pos) { + return false; + } + }); + PathingBehavior.INSTANCE.path(); + event.cancel(); + return; + } if (msg.toLowerCase().equals("reloadall")) { WorldProvider.INSTANCE.getCurrentWorld().cache.reloadAllFromDisk(); displayChatMessageRaw("ok"); From c6ca584847d2076a6e02a974d4bd70521bdb51c4 Mon Sep 17 00:00:00 2001 From: Brady Date: Sat, 25 Aug 2018 17:24:00 -0500 Subject: [PATCH 63/86] Clean up isDoorPassable --- .../pathing/movement/MovementHelper.java | 42 +++++++------------ 1 file changed, 14 insertions(+), 28 deletions(-) diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java index ed52f8cc..547043e8 100644 --- a/src/main/java/baritone/pathing/movement/MovementHelper.java +++ b/src/main/java/baritone/pathing/movement/MovementHelper.java @@ -30,6 +30,7 @@ import net.minecraft.client.entity.EntityPlayerSP; import net.minecraft.entity.Entity; import net.minecraft.init.Blocks; import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumFacing; import net.minecraft.util.NonNullList; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.RayTraceResult; @@ -119,41 +120,26 @@ public interface MovementHelper extends ActionCosts, Helper { } static boolean isDoorPassable(BlockPos doorPos, BlockPos playerPos) { - IBlockState door = BlockStateInterface.get(doorPos); - if (!(door.getBlock() instanceof BlockDoor)) { - return true; - } - String facing = door.getValue(BlockDoor.FACING).getName(); - boolean open = door.getValue(BlockDoor.OPEN).booleanValue(); - /** - * yes this is dumb - * change it if you want - */ - String playerFacing = ""; - if (playerPos.equals(doorPos)) { + if (playerPos.equals(doorPos)) return false; - } + + IBlockState state = BlockStateInterface.get(doorPos); + if (!(state.getBlock() instanceof BlockDoor)) + return true; + + EnumFacing.Axis facing = state.getValue(BlockDoor.FACING).getAxis(); + boolean open = state.getValue(BlockDoor.OPEN); + + EnumFacing.Axis playerFacing; if (playerPos.north().equals(doorPos) || playerPos.south().equals(doorPos)) { - playerFacing = "northsouth"; + playerFacing = EnumFacing.Axis.Z; } else if (playerPos.east().equals(doorPos) || playerPos.west().equals(doorPos)) { - playerFacing = "eastwest"; + playerFacing = EnumFacing.Axis.X; } else { return true; } - if (facing == "north" || facing == "south") { - if (open) { - return playerFacing == "northsouth"; - } else { - return playerFacing == "eastwest"; - } - } else { - if (open) { - return playerFacing == "eastwest"; - } else { - return playerFacing == "northsouth"; - } - } + return (facing == playerFacing) == open; } static boolean avoidWalkingInto(Block block) { From 879d72d715dc1e168668e6632c3fc6d81ac961ab Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sat, 25 Aug 2018 15:34:19 -0700 Subject: [PATCH 64/86] don't sprint if allowSprint is false --- .../baritone/pathing/movement/movements/MovementDiagonal.java | 3 ++- .../baritone/pathing/movement/movements/MovementTraverse.java | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java index 274f23c6..8709dfc3 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java @@ -17,6 +17,7 @@ package baritone.pathing.movement.movements; +import baritone.Baritone; import baritone.pathing.movement.CalculationContext; import baritone.pathing.movement.Movement; import baritone.pathing.movement.MovementHelper; @@ -62,7 +63,7 @@ public class MovementDiagonal extends Movement { state.setStatus(MovementState.MovementStatus.SUCCESS); return state; } - if (!BlockStateInterface.isLiquid(playerFeet())) { + if (!BlockStateInterface.isLiquid(playerFeet()) && Baritone.settings().allowSprint.get()) { player().setSprinting(true); } MovementHelper.moveTowards(state, dest); diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java index aac418a6..451c5ca6 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java @@ -17,6 +17,7 @@ package baritone.pathing.movement.movements; +import baritone.Baritone; import baritone.behavior.impl.LookBehaviorUtils; import baritone.pathing.movement.CalculationContext; import baritone.pathing.movement.Movement; @@ -174,7 +175,7 @@ public class MovementTraverse extends Movement { state.setStatus(MovementState.MovementStatus.SUCCESS); return state; } - if (wasTheBridgeBlockAlwaysThere && !BlockStateInterface.isLiquid(playerFeet())) { + if (wasTheBridgeBlockAlwaysThere && !BlockStateInterface.isLiquid(playerFeet()) && Baritone.settings().allowSprint.get()) { player().setSprinting(true); } Block destDown = BlockStateInterface.get(dest.down()).getBlock(); From 32a0f4eaac3883a5e049df9c7a73790c9df91d7d Mon Sep 17 00:00:00 2001 From: Brady Date: Sat, 25 Aug 2018 18:30:12 -0500 Subject: [PATCH 65/86] All around minor cleanups to movement classes --- .../baritone/pathing/movement/Movement.java | 17 ++++--- .../movement/movements/MovementAscend.java | 50 +++++++++---------- .../movement/movements/MovementDescend.java | 4 +- .../movement/movements/MovementDiagonal.java | 20 ++++---- .../movement/movements/MovementDownward.java | 1 + .../movement/movements/MovementFall.java | 9 ++-- .../movement/movements/MovementPillar.java | 50 ++++++++++++------- .../movement/movements/MovementTraverse.java | 23 +++++---- 8 files changed, 94 insertions(+), 80 deletions(-) diff --git a/src/main/java/baritone/pathing/movement/Movement.java b/src/main/java/baritone/pathing/movement/Movement.java index 73a42121..27cbb08e 100644 --- a/src/main/java/baritone/pathing/movement/Movement.java +++ b/src/main/java/baritone/pathing/movement/Movement.java @@ -33,6 +33,7 @@ import net.minecraft.util.math.RayTraceResult; import net.minecraft.util.math.Vec3d; import java.util.ArrayList; +import java.util.List; import java.util.Optional; import static baritone.utils.InputOverrideHandler.Input; @@ -268,15 +269,15 @@ public abstract class Movement implements Helper, MovementHelper { return state; } - public ArrayList toBreakCached = null; - public ArrayList toPlaceCached = null; - public ArrayList toWalkIntoCached = null; + public List toBreakCached = null; + public List toPlaceCached = null; + public List toWalkIntoCached = null; - public ArrayList toBreak() { + public List toBreak() { if (toBreakCached != null) { return toBreakCached; } - ArrayList result = new ArrayList<>(); + List result = new ArrayList<>(); for (BlockPos positionToBreak : positionsToBreak) { if (!MovementHelper.canWalkThrough(positionToBreak)) { result.add(positionToBreak); @@ -286,11 +287,11 @@ public abstract class Movement implements Helper, MovementHelper { return result; } - public ArrayList toPlace() { + public List toPlace() { if (toPlaceCached != null) { return toPlaceCached; } - ArrayList result = new ArrayList<>(); + List result = new ArrayList<>(); for (BlockPos positionToBreak : positionsToPlace) { if (!MovementHelper.canWalkOn(positionToBreak)) { result.add(positionToBreak); @@ -300,7 +301,7 @@ public abstract class Movement implements Helper, MovementHelper { return result; } - public ArrayList toWalkInto() { // overridden by movementdiagonal + public List toWalkInto() { // overridden by movementdiagonal if (toWalkIntoCached == null) { toWalkIntoCached = new ArrayList<>(); } diff --git a/src/main/java/baritone/pathing/movement/movements/MovementAscend.java b/src/main/java/baritone/pathing/movement/movements/MovementAscend.java index 956d7091..f3225337 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementAscend.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementAscend.java @@ -130,9 +130,9 @@ public class MovementAscend extends Movement { default: return state; } + if (playerFeet().equals(dest)) { - state.setStatus(MovementStatus.SUCCESS); - return state; + return state.setStatus(MovementStatus.SUCCESS); } if (!MovementHelper.canWalkOn(positionsToPlace[0])) { @@ -146,17 +146,21 @@ public class MovementAscend extends Movement { double faceZ = (dest.getZ() + anAgainst.getZ() + 1.0D) * 0.5D; state.setTarget(new MovementState.MovementTarget(Utils.calcRotationFromVec3d(playerHead(), new Vec3d(faceX, faceY, faceZ), playerRotations()), true)); EnumFacing side = Minecraft.getMinecraft().objectMouseOver.sideHit; - if (Objects.equals(LookBehaviorUtils.getSelectedBlock().orElse(null), anAgainst) && LookBehaviorUtils.getSelectedBlock().get().offset(side).equals(positionsToPlace[0])) { - ticksWithoutPlacement++; - state.setInput(InputOverrideHandler.Input.SNEAK, true); - if (player().isSneaking()) { - state.setInput(InputOverrideHandler.Input.CLICK_RIGHT, true); + + LookBehaviorUtils.getSelectedBlock().ifPresent(selectedBlock -> { + if (Objects.equals(selectedBlock, anAgainst) && selectedBlock.offset(side).equals(positionsToPlace[0])) { + ticksWithoutPlacement++; + state.setInput(InputOverrideHandler.Input.SNEAK, true); + if (player().isSneaking()) { + state.setInput(InputOverrideHandler.Input.CLICK_RIGHT, true); + } + if (ticksWithoutPlacement > 20) { + // After 20 ticks without placement, we might be standing in the way, move back + state.setInput(InputOverrideHandler.Input.MOVE_BACK, true); + } } - if (ticksWithoutPlacement > 20) { - state.setInput(InputOverrideHandler.Input.MOVE_BACK, true);//we might be standing in the way, move back - } - } - System.out.println("Trying to look at " + anAgainst + ", actually looking at" + LookBehaviorUtils.getSelectedBlock()); + System.out.println("Trying to look at " + anAgainst + ", actually looking at" + selectedBlock); + }); return state; } } @@ -165,28 +169,22 @@ public class MovementAscend extends Movement { MovementHelper.moveTowards(state, dest); if (headBonkClear()) { - state.setInput(InputOverrideHandler.Input.JUMP, true); - return state; + return state.setInput(InputOverrideHandler.Input.JUMP, true); } int xAxis = Math.abs(src.getX() - dest.getX()); // either 0 or 1 int zAxis = Math.abs(src.getZ() - dest.getZ()); // either 0 or 1 double flatDistToNext = xAxis * Math.abs((dest.getX() + 0.5D) - player().posX) + zAxis * Math.abs((dest.getZ() + 0.5D) - player().posZ); - double sideDist = zAxis * Math.abs((dest.getX() + 0.5D) - player().posX) + xAxis * Math.abs((dest.getZ() + 0.5D) - player().posZ); - //System.out.println(flatDistToNext + " " + sideDist); - if (flatDistToNext > 1.2) { + // System.out.println(flatDistToNext + " " + sideDist); + if (flatDistToNext > 1.2 || sideDist > 0.2) { return state; } - if (sideDist > 0.2) { - return state; - } - //once we are pointing the right way and moving, start jumping - //this is slightly more efficient because otherwise we might start jumping before moving, and fall down without moving onto the block we want to jump onto - //also wait until we are close enough, because we might jump and hit our head on an adjacent block - state.setInput(InputOverrideHandler.Input.JUMP, true); - return state; + // Once we are pointing the right way and moving, start jumping + // This is slightly more efficient because otherwise we might start jumping before moving, and fall down without moving onto the block we want to jump onto + // Also wait until we are close enough, because we might jump and hit our head on an adjacent block + return state.setInput(InputOverrideHandler.Input.JUMP, true); } private boolean headBonkClear() { @@ -194,7 +192,7 @@ public class MovementAscend extends Movement { for (int i = 0; i < 4; i++) { BlockPos check = startUp.offset(EnumFacing.byHorizontalIndex(i)); if (!MovementHelper.canWalkThrough(check)) { - // we might bonk our head + // We might bonk our head return false; } } diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDescend.java b/src/main/java/baritone/pathing/movement/movements/MovementDescend.java index dab57257..6e299bd1 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementDescend.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementDescend.java @@ -73,6 +73,7 @@ public class MovementDescend extends Movement { default: return state; } + BlockPos playerFeet = playerFeet(); if (playerFeet.equals(dest)) { if (BlockStateInterface.isLiquid(dest) || player().posY - playerFeet.getY() < 0.094) { // lilypads @@ -91,9 +92,6 @@ public class MovementDescend extends Movement { double fromStart = Math.sqrt(x * x + z * z); if (!playerFeet.equals(dest) || ab > 0.25) { BlockPos fakeDest = new BlockPos(dest.getX() * 2 - src.getX(), dest.getY(), dest.getZ() * 2 - src.getZ()); - double diffX2 = player().posX - (fakeDest.getX() + 0.5); - double diffZ2 = player().posZ - (fakeDest.getZ() + 0.5); - double d = Math.sqrt(diffX2 * diffX2 + diffZ2 * diffZ2); if (numTicks++ < 20) { MovementHelper.moveTowards(state, fakeDest); if (fromStart > 1.25) { diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java index 8709dfc3..b570d0f5 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 net.minecraft.util.EnumFacing; import net.minecraft.util.math.BlockPos; import java.util.ArrayList; +import java.util.List; public class MovementDiagonal extends Movement { @@ -59,6 +60,7 @@ public class MovementDiagonal extends Movement { default: return state; } + if (playerFeet().equals(dest)) { state.setStatus(MovementState.MovementStatus.SUCCESS); return state; @@ -81,7 +83,7 @@ public class MovementDiagonal extends Movement { } double multiplier = WALK_ONE_BLOCK_COST; - // for either possible soul sand, that affects half of our walking + // For either possible soul sand, that affects half of our walking if (destWalkOn.getBlock().equals(Blocks.SOUL_SAND)) { multiplier += (WALK_ONE_OVER_SOUL_SAND_COST - WALK_ONE_BLOCK_COST) / 2; } @@ -117,17 +119,17 @@ public class MovementDiagonal extends Movement { } } if (BlockStateInterface.isWater(src) || BlockStateInterface.isWater(dest)) { - // ignore previous multiplier - // whatever we were walking on (possibly soul sand) doesn't matter as we're actually floating on water - // not even touching the blocks below + // Ignore previous multiplier + // Whatever we were walking on (possibly soul sand) doesn't matter as we're actually floating on water + // Not even touching the blocks below multiplier = WALK_ONE_IN_WATER_COST; } if (optionA != 0 || optionB != 0) { multiplier *= SQRT_2 - 0.001; // TODO tune } if (multiplier == WALK_ONE_BLOCK_COST && context.canSprint()) { - // if we aren't edging around anything, and we aren't in water or soul sand - // we can sprint =D + // If we aren't edging around anything, and we aren't in water or soul sand + // We can sprint =D multiplier = SPRINT_ONE_BLOCK_COST; } return multiplier * SQRT_2; @@ -139,7 +141,7 @@ public class MovementDiagonal extends Movement { } @Override - public ArrayList toBreak() { + public List toBreak() { if (toBreakCached != null) { return toBreakCached; } @@ -154,11 +156,11 @@ public class MovementDiagonal extends Movement { } @Override - public ArrayList toWalkInto() { + public List toWalkInto() { if (toWalkIntoCached == null) { toWalkIntoCached = new ArrayList<>(); } - ArrayList result = new ArrayList<>(); + List result = new ArrayList<>(); for (int i = 0; i < 4; i++) { if (!MovementHelper.canWalkThrough(positionsToBreak[i])) { result.add(positionsToBreak[i]); diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDownward.java b/src/main/java/baritone/pathing/movement/movements/MovementDownward.java index 285053c2..724b8688 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementDownward.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementDownward.java @@ -68,6 +68,7 @@ public class MovementDownward extends Movement { default: return state; } + if (playerFeet().equals(dest)) { state.setStatus(MovementState.MovementStatus.SUCCESS); return state; diff --git a/src/main/java/baritone/pathing/movement/movements/MovementFall.java b/src/main/java/baritone/pathing/movement/movements/MovementFall.java index 6d96b365..a3018c4c 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementFall.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementFall.java @@ -67,10 +67,10 @@ public class MovementFall extends Movement { } for (int i = 2; i < positionsToBreak.length; i++) { // TODO is this the right check here? - // miningDurationTicks is all right, but shouldn't it be canWalkThrough instead? - // lilypads (i think?) are 0 ticks to mine, but they definitely cause fall damage - // same thing for falling through water... we can't actually do that - // and falling through signs is possible, but they do have a mining duration, right? + // MiningDurationTicks is all right, but shouldn't it be canWalkThrough instead? + // Lilypads (i think?) are 0 ticks to mine, but they definitely cause fall damage + // Same thing for falling through water... we can't actually do that + // And falling through signs is possible, but they do have a mining duration, right? if (MovementHelper.getMiningDurationTicks(context, positionsToBreak[i]) > 0) { //can't break while falling return COST_INF; @@ -90,6 +90,7 @@ public class MovementFall extends Movement { default: return state; } + BlockPos playerFeet = playerFeet(); Optional targetRotation = Optional.empty(); if (!BlockStateInterface.isWater(dest) && src.getY() - dest.getY() > Baritone.settings().maxFallHeightNoWater.get() && !playerFeet.equals(dest)) { diff --git a/src/main/java/baritone/pathing/movement/movements/MovementPillar.java b/src/main/java/baritone/pathing/movement/movements/MovementPillar.java index 5dcef948..dba55466 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementPillar.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementPillar.java @@ -115,6 +115,7 @@ public class MovementPillar extends Movement { default: return state; } + IBlockState fromDown = BlockStateInterface.get(src); boolean ladder = fromDown.getBlock() instanceof BlockLadder || fromDown.getBlock() instanceof BlockVine; boolean vine = fromDown.getBlock() instanceof BlockVine; @@ -123,57 +124,68 @@ public class MovementPillar extends Movement { Utils.getBlockPosCenter(positionsToPlace[0]), new Rotation(mc.player.rotationYaw, mc.player.rotationPitch)), true)); } - EntityPlayerSP thePlayer = Minecraft.getMinecraft().player; + boolean blockIsThere = MovementHelper.canWalkOn(src) || ladder; if (ladder) { BlockPos against = vine ? getAgainst(src) : src.offset(fromDown.getValue(BlockLadder.FACING).getOpposite()); if (against == null) { displayChatMessageRaw("Unable to climb vines"); - state.setStatus(MovementState.MovementStatus.UNREACHABLE); - return state; + return state.setStatus(MovementState.MovementStatus.UNREACHABLE); } - if (playerFeet().equals(against.up()) || playerFeet().equals(dest)) { - state.setStatus(MovementState.MovementStatus.SUCCESS); - return state; + + if (playerFeet().equals(against.up()) || playerFeet().equals(dest)) + return state.setStatus(MovementState.MovementStatus.SUCCESS); + + /* + if (thePlayer.getPosition0().getX() != from.getX() || thePlayer.getPosition0().getZ() != from.getZ()) { + Baritone.moveTowardsBlock(from); } - /*if (thePlayer.getPosition0().getX() != from.getX() || thePlayer.getPosition0().getZ() != from.getZ()) { - Baritone.moveTowardsBlock(from); - }*/ + */ + MovementHelper.moveTowards(state, against); return state; } else { - if (!MovementHelper.throwaway(true)) {//get ready to place a throwaway block + // Get ready to place a throwaway block + if (!MovementHelper.throwaway(true)) { state.setStatus(MovementState.MovementStatus.UNREACHABLE); return state; } + numTicks++; - state.setInput(InputOverrideHandler.Input.JUMP, thePlayer.posY < dest.getY()); //if our Y coordinate is above our goal, stop jumping + // If our Y coordinate is above our goal, stop jumping + state.setInput(InputOverrideHandler.Input.JUMP, player().posY < dest.getY()); state.setInput(InputOverrideHandler.Input.SNEAK, true); - //otherwise jump + + // Otherwise jump if (numTicks > 40) { - double diffX = thePlayer.posX - (dest.getX() + 0.5); - double diffZ = thePlayer.posZ - (dest.getZ() + 0.5); + double diffX = player().posX - (dest.getX() + 0.5); + double diffZ = player().posZ - (dest.getZ() + 0.5); double dist = Math.sqrt(diffX * diffX + diffZ * diffZ); if (dist > 0.17) {//why 0.17? because it seemed like a good number, that's why //[explanation added after baritone port lol] also because it needs to be less than 0.2 because of the 0.3 sneak limit //and 0.17 is reasonably less than 0.2 - state.setInput(InputOverrideHandler.Input.MOVE_FORWARD, true);//if it's been more than forty ticks of trying to jump and we aren't done yet, go forward, maybe we are stuck + + // If it's been more than forty ticks of trying to jump and we aren't done yet, go forward, maybe we are stuck + state.setInput(InputOverrideHandler.Input.MOVE_FORWARD, true); } } + if (!blockIsThere) { Block fr = BlockStateInterface.get(src).getBlock(); if (!(fr instanceof BlockAir || fr.isReplaceable(Minecraft.getMinecraft().world, src))) { state.setInput(InputOverrideHandler.Input.CLICK_LEFT, true); blockIsThere = false; } else if (Minecraft.getMinecraft().player.isSneaking()) { - state.setInput(InputOverrideHandler.Input.CLICK_RIGHT, true);//constantly right click + state.setInput(InputOverrideHandler.Input.CLICK_RIGHT, true); } } } - if (playerFeet().equals(dest) && blockIsThere) {//if we are at our goal and the block below us is placed - state.setStatus(MovementState.MovementStatus.SUCCESS); - return state;//we are done + + // If we are at our goal and the block below us is placed + if (playerFeet().equals(dest) && blockIsThere) { + return state.setStatus(MovementState.MovementStatus.SUCCESS); } + return state; } } \ No newline at end of file diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java index 451c5ca6..c784f07b 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java @@ -92,15 +92,15 @@ public class MovementTraverse extends Movement { } if (MovementHelper.canWalkThrough(positionsToBreak[0], pb0) && MovementHelper.canWalkThrough(positionsToBreak[1], pb1)) { if (WC == WALK_ONE_BLOCK_COST && context.canSprint()) { - // if there's nothing in the way, and this isn't water or soul sand, and we aren't sneak placing - // we can sprint =D + // If there's nothing in the way, and this isn't water or soul sand, and we aren't sneak placing + // We can sprint =D WC = SPRINT_ONE_BLOCK_COST; } return WC; } - //double hardness1 = blocksToBreak[0].getBlockHardness(Minecraft.getMinecraft().world, positionsToBreak[0]); - //double hardness2 = blocksToBreak[1].getBlockHardness(Minecraft.getMinecraft().world, positionsToBreak[1]); - //Out.log("Can't walk through " + blocksToBreak[0] + " (hardness" + hardness1 + ") or " + blocksToBreak[1] + " (hardness " + hardness2 + ")"); + // double hardness1 = blocksToBreak[0].getBlockHardness(Minecraft.getMinecraft().world, positionsToBreak[0]); + // double hardness2 = blocksToBreak[1].getBlockHardness(Minecraft.getMinecraft().world, positionsToBreak[1]); + // Out.log("Can't walk through " + blocksToBreak[0] + " (hardness" + hardness1 + ") or " + blocksToBreak[1] + " (hardness " + hardness2 + ")"); return WC + getTotalHardnessOfBlocksToBreak(context); } else {//this is a bridge, so we need to place a block Block srcDown = BlockStateInterface.get(src.down()).getBlock(); @@ -125,7 +125,7 @@ public class MovementTraverse extends Movement { return WC + context.placeBlockCost() + getTotalHardnessOfBlocksToBreak(context); } return COST_INF; - //Out.log("Can't walk on " + Baritone.get(positionsToPlace[0]).getBlock()); + // Out.log("Can't walk on " + Baritone.get(positionsToPlace[0]).getBlock()); } } @@ -140,6 +140,7 @@ public class MovementTraverse extends Movement { default: return state; } + Block fd = BlockStateInterface.get(src.down()).getBlock(); boolean ladder = fd instanceof BlockLadder || fd instanceof BlockVine; IBlockState pb0 = BlockStateInterface.get(positionsToBreak[0]); @@ -161,6 +162,7 @@ public class MovementTraverse extends Movement { } } } + boolean isTheBridgeBlockThere = MovementHelper.canWalkOn(positionsToPlace[0]) || ladder; BlockPos whereAmI = playerFeet(); if (whereAmI.getY() != dest.getY() && !ladder) { @@ -170,6 +172,7 @@ public class MovementTraverse extends Movement { } return state; } + if (isTheBridgeBlockThere) { if (playerFeet().equals(dest)) { state.setStatus(MovementState.MovementStatus.SUCCESS); @@ -202,20 +205,18 @@ public class MovementTraverse extends Movement { EnumFacing side = Minecraft.getMinecraft().objectMouseOver.sideHit; if (Objects.equals(LookBehaviorUtils.getSelectedBlock().orElse(null), against1) && Minecraft.getMinecraft().player.isSneaking()) { if (LookBehaviorUtils.getSelectedBlock().get().offset(side).equals(positionsToPlace[0])) { - state.setInput(InputOverrideHandler.Input.CLICK_RIGHT, true); - return state; + return state.setInput(InputOverrideHandler.Input.CLICK_RIGHT, true); } else { // Out.gui("Wrong. " + side + " " + LookBehaviorUtils.getSelectedBlock().get().offset(side) + " " + positionsToPlace[0], Out.Mode.Debug); } } - state.setInput(InputOverrideHandler.Input.CLICK_LEFT, true); System.out.println("Trying to look at " + against1 + ", actually looking at" + LookBehaviorUtils.getSelectedBlock()); - return state; + return state.setInput(InputOverrideHandler.Input.CLICK_LEFT, true); } } state.setInput(InputOverrideHandler.Input.SNEAK, true); if (whereAmI.equals(dest)) { - // if we are in the block that we are trying to get to, we are sneaking over air and we need to place a block beneath us against the one we just walked off of + // If we are in the block that we are trying to get to, we are sneaking over air and we need to place a block beneath us against the one we just walked off of // Out.log(from + " " + to + " " + faceX + "," + faceY + "," + faceZ + " " + whereAmI); if (!MovementHelper.throwaway(true)) {// get ready to place a throwaway block displayChatMessageRaw("bb pls get me some blocks. dirt or cobble"); From 72c2a58ef269a07b26838363fb2757374e24da87 Mon Sep 17 00:00:00 2001 From: Brady Date: Sat, 25 Aug 2018 18:35:41 -0500 Subject: [PATCH 66/86] Replace ArrayList type fields with List --- src/main/java/baritone/Settings.java | 2 +- src/main/java/baritone/chunk/CachedRegion.java | 2 +- .../baritone/pathing/movement/movements/MovementDiagonal.java | 2 +- src/main/java/baritone/utils/ExampleBaritoneControl.java | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/main/java/baritone/Settings.java b/src/main/java/baritone/Settings.java index 3b64e70a..e596df14 100644 --- a/src/main/java/baritone/Settings.java +++ b/src/main/java/baritone/Settings.java @@ -310,7 +310,7 @@ public class Settings { @SuppressWarnings("unchecked") public List> getByValueType(Class klass) { - ArrayList> result = new ArrayList<>(); + List> result = new ArrayList<>(); for (Setting setting : allSettings) { if (setting.klass.equals(klass)) { result.add((Setting) setting); diff --git a/src/main/java/baritone/chunk/CachedRegion.java b/src/main/java/baritone/chunk/CachedRegion.java index 514d1b23..923edc16 100644 --- a/src/main/java/baritone/chunk/CachedRegion.java +++ b/src/main/java/baritone/chunk/CachedRegion.java @@ -235,7 +235,7 @@ public final class CachedRegion implements IBlockTypeAccess { short numSpecialBlockTypes = in.readShort(); for (int i = 0; i < numSpecialBlockTypes; i++) { String blockName = in.readUTF(); - ArrayList locs = new ArrayList<>(); + List locs = new ArrayList<>(); location[x][z].put(blockName, locs); short numLocations = in.readShort(); for (int j = 0; j < numLocations; j++) { diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java index b570d0f5..7bde41c7 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java @@ -145,7 +145,7 @@ public class MovementDiagonal extends Movement { if (toBreakCached != null) { return toBreakCached; } - ArrayList result = new ArrayList<>(); + List result = new ArrayList<>(); for (int i = 4; i < 6; i++) { if (!MovementHelper.canWalkThrough(positionsToBreak[i])) { result.add(positionsToBreak[i]); diff --git a/src/main/java/baritone/utils/ExampleBaritoneControl.java b/src/main/java/baritone/utils/ExampleBaritoneControl.java index 58e93658..e7c637d7 100644 --- a/src/main/java/baritone/utils/ExampleBaritoneControl.java +++ b/src/main/java/baritone/utils/ExampleBaritoneControl.java @@ -272,7 +272,7 @@ public class ExampleBaritoneControl extends Behavior { } if (msg.toLowerCase().equals("costs")) { Movement[] movements = AStarPathFinder.getConnectedPositions(new BetterBlockPos(playerFeet()), new CalculationContext()); - ArrayList moves = new ArrayList<>(Arrays.asList(movements)); + List moves = new ArrayList<>(Arrays.asList(movements)); moves.sort(Comparator.comparingDouble(movement -> movement.getCost(new CalculationContext()))); for (Movement move : moves) { String[] parts = move.getClass().toString().split("\\."); From f834bcec082df7d487f4331bb47cec640ce232c2 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sat, 25 Aug 2018 17:09:35 -0700 Subject: [PATCH 67/86] add BlockFalling check for MovementFall, fixes #94 --- .../baritone/pathing/movement/movements/MovementFall.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/main/java/baritone/pathing/movement/movements/MovementFall.java b/src/main/java/baritone/pathing/movement/movements/MovementFall.java index 6d96b365..1910c928 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementFall.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementFall.java @@ -30,6 +30,7 @@ import baritone.utils.InputOverrideHandler; import baritone.utils.Rotation; import baritone.utils.Utils; import net.minecraft.block.Block; +import net.minecraft.block.BlockFalling; import net.minecraft.init.Items; import net.minecraft.item.ItemStack; import net.minecraft.util.math.BlockPos; @@ -65,6 +66,9 @@ public class MovementFall extends Movement { if (frontTwo >= COST_INF) { return COST_INF; } + if (BlockStateInterface.get(positionsToBreak[0].up()).getBlock() instanceof BlockFalling) { + return COST_INF; + } for (int i = 2; i < positionsToBreak.length; i++) { // TODO is this the right check here? // miningDurationTicks is all right, but shouldn't it be canWalkThrough instead? From 7d863ebfed5fe04a28b81a2ce02320392e693710 Mon Sep 17 00:00:00 2001 From: Brady Date: Sat, 25 Aug 2018 23:03:25 -0500 Subject: [PATCH 68/86] Intercept toStringHelper to fix BlockPos obfuscated name, fixes #95 --- .../baritone/launch/mixins/MixinVec3i.java | 49 +++++++++++++++++++ src/main/resources/mixins.baritone.json | 1 + 2 files changed, 50 insertions(+) create mode 100644 src/main/java/baritone/launch/mixins/MixinVec3i.java diff --git a/src/main/java/baritone/launch/mixins/MixinVec3i.java b/src/main/java/baritone/launch/mixins/MixinVec3i.java new file mode 100644 index 00000000..84823015 --- /dev/null +++ b/src/main/java/baritone/launch/mixins/MixinVec3i.java @@ -0,0 +1,49 @@ +/* + * This file is part of Baritone. + * + * Baritone is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Baritone. If not, see . + */ + +package baritone.launch.mixins; + +import com.google.common.base.MoreObjects; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.Vec3i; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Redirect; + +/** + * @author Brady + * @since 8/25/2018 + */ +@Mixin(Vec3i.class) +public class MixinVec3i { + + @Redirect( + method = "toString", + at = @At( + value = "INVOKE", + target = "com/google/common/base/MoreObjects.toStringHelper(Ljava/lang/Object;)Lcom/google/common/base/MoreObjects$ToStringHelper;" + ) + ) + private MoreObjects.ToStringHelper toStringHelper(Object object) { + + if (object.getClass().equals(BlockPos.class)) { + return MoreObjects.toStringHelper("BlockPos"); + } + + return MoreObjects.toStringHelper(object); + } +} diff --git a/src/main/resources/mixins.baritone.json b/src/main/resources/mixins.baritone.json index 523662db..2735cdd6 100755 --- a/src/main/resources/mixins.baritone.json +++ b/src/main/resources/mixins.baritone.json @@ -19,6 +19,7 @@ "MixinMinecraft", "MixinNetHandlerPlayClient", "MixinNetworkManager", + "MixinVec3i", "MixinWorldClient", "accessor.IAnvilChunkLoader", From 1801551d3b7e1e45512e5c86939c5bee7a4232cb Mon Sep 17 00:00:00 2001 From: Brady Date: Sat, 25 Aug 2018 23:12:43 -0500 Subject: [PATCH 69/86] A less atrocious approach to fixing 95 --- .../{MixinVec3i.java => MixinBlockPos.java} | 28 ++++++++----------- src/main/resources/mixins.baritone.json | 2 +- 2 files changed, 12 insertions(+), 18 deletions(-) rename src/main/java/baritone/launch/mixins/{MixinVec3i.java => MixinBlockPos.java} (57%) diff --git a/src/main/java/baritone/launch/mixins/MixinVec3i.java b/src/main/java/baritone/launch/mixins/MixinBlockPos.java similarity index 57% rename from src/main/java/baritone/launch/mixins/MixinVec3i.java rename to src/main/java/baritone/launch/mixins/MixinBlockPos.java index 84823015..1cf52132 100644 --- a/src/main/java/baritone/launch/mixins/MixinVec3i.java +++ b/src/main/java/baritone/launch/mixins/MixinBlockPos.java @@ -21,29 +21,23 @@ import com.google.common.base.MoreObjects; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.Vec3i; import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.injection.At; -import org.spongepowered.asm.mixin.injection.Redirect; + +import javax.annotation.Nonnull; /** * @author Brady * @since 8/25/2018 */ -@Mixin(Vec3i.class) -public class MixinVec3i { +@Mixin(BlockPos.class) +public abstract class MixinBlockPos extends Vec3i { - @Redirect( - method = "toString", - at = @At( - value = "INVOKE", - target = "com/google/common/base/MoreObjects.toStringHelper(Ljava/lang/Object;)Lcom/google/common/base/MoreObjects$ToStringHelper;" - ) - ) - private MoreObjects.ToStringHelper toStringHelper(Object object) { + public MixinBlockPos(int xIn, int yIn, int zIn) { + super(xIn, yIn, zIn); + } - if (object.getClass().equals(BlockPos.class)) { - return MoreObjects.toStringHelper("BlockPos"); - } - - return MoreObjects.toStringHelper(object); + @Override + @Nonnull + public String toString() { + return MoreObjects.toStringHelper("BlockPos").add("x", this.getX()).add("y", this.getY()).add("z", this.getZ()).toString(); } } diff --git a/src/main/resources/mixins.baritone.json b/src/main/resources/mixins.baritone.json index 2735cdd6..52aa62fd 100755 --- a/src/main/resources/mixins.baritone.json +++ b/src/main/resources/mixins.baritone.json @@ -8,6 +8,7 @@ "maxShiftBy": 2 }, "client": [ + "MixinBlockPos", "MixinEntity", "MixinEntityPlayerSP", "MixinEntityRenderer", @@ -19,7 +20,6 @@ "MixinMinecraft", "MixinNetHandlerPlayClient", "MixinNetworkManager", - "MixinVec3i", "MixinWorldClient", "accessor.IAnvilChunkLoader", From 5ec99977face3d15257d5c4672a9fd04f01bd923 Mon Sep 17 00:00:00 2001 From: Brady Date: Sun, 26 Aug 2018 00:09:44 -0500 Subject: [PATCH 70/86] Fix water bucket falling, fixes #91 --- .../movement/movements/MovementFall.java | 26 +++++----- .../java/baritone/utils/RayTraceUtils.java | 47 +++++++++++++++++++ 2 files changed, 60 insertions(+), 13 deletions(-) create mode 100644 src/main/java/baritone/utils/RayTraceUtils.java diff --git a/src/main/java/baritone/pathing/movement/movements/MovementFall.java b/src/main/java/baritone/pathing/movement/movements/MovementFall.java index 86597f2a..707a997b 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementFall.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementFall.java @@ -18,26 +18,20 @@ package baritone.pathing.movement.movements; import baritone.Baritone; -import baritone.behavior.impl.LookBehaviorUtils; import baritone.pathing.movement.CalculationContext; import baritone.pathing.movement.Movement; import baritone.pathing.movement.MovementHelper; import baritone.pathing.movement.MovementState; import baritone.pathing.movement.MovementState.MovementStatus; import baritone.pathing.movement.MovementState.MovementTarget; -import baritone.utils.BlockStateInterface; -import baritone.utils.InputOverrideHandler; -import baritone.utils.Rotation; -import baritone.utils.Utils; -import net.minecraft.block.Block; +import baritone.utils.*; import net.minecraft.block.BlockFalling; import net.minecraft.init.Items; import net.minecraft.item.ItemStack; import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.RayTraceResult; import net.minecraft.util.math.Vec3d; -import java.util.Optional; - public class MovementFall extends Movement { private static final ItemStack STACK_BUCKET_WATER = new ItemStack(Items.WATER_BUCKET); @@ -96,20 +90,26 @@ public class MovementFall extends Movement { } BlockPos playerFeet = playerFeet(); - Optional targetRotation = Optional.empty(); + Rotation targetRotation = null; if (!BlockStateInterface.isWater(dest) && src.getY() - dest.getY() > Baritone.settings().maxFallHeightNoWater.get() && !playerFeet.equals(dest)) { if (!player().inventory.hasItemStack(STACK_BUCKET_WATER) || world().provider.isNether()) { // TODO check if water bucket is on hotbar or main inventory state.setStatus(MovementStatus.UNREACHABLE); return state; } + if (player().posY - dest.getY() < mc.playerController.getBlockReachDistance()) { player().inventory.currentItem = player().inventory.getSlotFor(STACK_BUCKET_WATER); - targetRotation = LookBehaviorUtils.reachable((BlockStateInterface.get(dest).getCollisionBoundingBox(mc.world, dest) == Block.NULL_AABB) ? dest : dest.down()); + + targetRotation = new Rotation(player().rotationYaw, 90.0F); + + RayTraceResult trace = RayTraceUtils.simulateRayTrace(player().rotationYaw, 90.0F); + if (trace != null && trace.typeOfHit == RayTraceResult.Type.BLOCK) { + state.setInput(InputOverrideHandler.Input.CLICK_RIGHT, true); + } } } - if (targetRotation.isPresent()) { - state.setInput(InputOverrideHandler.Input.CLICK_RIGHT, true) - .setTarget(new MovementTarget(targetRotation.get(), true)); + if (targetRotation != null) { + state.setTarget(new MovementTarget(targetRotation, true)); } else { state.setTarget(new MovementTarget(Utils.calcRotationFromVec3d(playerHead(), Utils.getBlockPosCenter(dest)), false)); } diff --git a/src/main/java/baritone/utils/RayTraceUtils.java b/src/main/java/baritone/utils/RayTraceUtils.java new file mode 100644 index 00000000..f6547454 --- /dev/null +++ b/src/main/java/baritone/utils/RayTraceUtils.java @@ -0,0 +1,47 @@ +/* + * This file is part of Baritone. + * + * Baritone is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Baritone. If not, see . + */ + +package baritone.utils; + +import net.minecraft.util.math.RayTraceResult; + +/** + * @author Brady + * @since 8/25/2018 + */ +public final class RayTraceUtils implements Helper { + + private RayTraceUtils() {} + + public static RayTraceResult simulateRayTrace(float yaw, float pitch) { + RayTraceResult oldTrace = mc.objectMouseOver; + float oldYaw = mc.player.rotationYaw; + float oldPitch = mc.player.rotationPitch; + + mc.player.rotationYaw = yaw; + mc.player.rotationPitch = pitch; + + mc.entityRenderer.getMouseOver(1.0F); + RayTraceResult result = mc.objectMouseOver; + mc.objectMouseOver = oldTrace; + + mc.player.rotationYaw = oldYaw; + mc.player.rotationPitch = oldPitch; + + return result; + } +} From f1fcacf2418572953489d35320f61d4896bbbb3c Mon Sep 17 00:00:00 2001 From: Brady Date: Sun, 26 Aug 2018 01:45:33 -0500 Subject: [PATCH 71/86] Fix refmap not generating with the proper name --- build.gradle | 5 +++++ src/main/resources/mixins.baritone.json | 2 +- 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/build.gradle b/build.gradle index b11287d7..7dd75be8 100755 --- a/build.gradle +++ b/build.gradle @@ -75,3 +75,8 @@ dependencies { } testImplementation 'junit:junit:4.12' } + +mixin { + defaultObfuscationEnv notch + add sourceSets.main, 'mixins.baritone.refmap.json' +} diff --git a/src/main/resources/mixins.baritone.json b/src/main/resources/mixins.baritone.json index 52aa62fd..c0b5d3bb 100755 --- a/src/main/resources/mixins.baritone.json +++ b/src/main/resources/mixins.baritone.json @@ -1,7 +1,7 @@ { "required": true, "package": "baritone.launch.mixins", - "refmap": "mixin.refmap.json", + "refmap": "mixins.baritone.refmap.json", "compatibilityLevel": "JAVA_8", "verbose": false, "injectors": { From 8de7963c74f147aa119a5c3dae234fd77d457588 Mon Sep 17 00:00:00 2001 From: Brady Date: Sun, 26 Aug 2018 02:17:52 -0500 Subject: [PATCH 72/86] Allow opening of fence gates that are blocking movement, fixes #46 --- .../pathing/movement/MovementHelper.java | 31 +++++++++++++++---- .../movement/movements/MovementTraverse.java | 28 ++++++++++++----- 2 files changed, 45 insertions(+), 14 deletions(-) diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java index 547043e8..34c65ae6 100644 --- a/src/main/java/baritone/pathing/movement/MovementHelper.java +++ b/src/main/java/baritone/pathing/movement/MovementHelper.java @@ -24,6 +24,7 @@ import baritone.pathing.movement.movements.MovementDescend; import baritone.pathing.movement.movements.MovementFall; import baritone.utils.*; import net.minecraft.block.*; +import net.minecraft.block.properties.PropertyBool; import net.minecraft.block.state.IBlockState; import net.minecraft.client.Minecraft; import net.minecraft.client.entity.EntityPlayerSP; @@ -77,13 +78,13 @@ public interface MovementHelper extends ActionCosts, Helper { || block instanceof BlockEndPortal) {//you can't actually walk through a lilypad from the side, and you shouldn't walk through fire return false; } - if (block instanceof BlockDoor) { + if (block instanceof BlockDoor || block instanceof BlockFenceGate) { if (block == Blocks.IRON_DOOR) { return false; } return true; // we can just open the door } - if (block instanceof BlockSnow || block instanceof BlockFenceGate || block instanceof BlockTrapDoor) { + if (block instanceof BlockSnow || block instanceof BlockTrapDoor) { // we've already checked doors // so the only remaining dynamic isPassables are snow, fence gate, and trapdoor // if they're cached as a top block, we don't know their metadata @@ -127,13 +128,31 @@ public interface MovementHelper extends ActionCosts, Helper { if (!(state.getBlock() instanceof BlockDoor)) return true; - EnumFacing.Axis facing = state.getValue(BlockDoor.FACING).getAxis(); - boolean open = state.getValue(BlockDoor.OPEN); + return isHorizontalBlockPassable(doorPos, state, playerPos, BlockDoor.OPEN); + } + + static boolean isGatePassable(BlockPos gatePos, BlockPos playerPos) { + if (playerPos.equals(gatePos)) + return false; + + IBlockState state = BlockStateInterface.get(gatePos); + if (!(state.getBlock() instanceof BlockFenceGate)) + return true; + + return isHorizontalBlockPassable(gatePos, state, playerPos, BlockFenceGate.OPEN); + } + + static boolean isHorizontalBlockPassable(BlockPos blockPos, IBlockState blockState, BlockPos playerPos, PropertyBool propertyOpen) { + if (playerPos.equals(blockPos)) + return false; + + EnumFacing.Axis facing = blockState.getValue(BlockHorizontal.FACING).getAxis(); + boolean open = blockState.getValue(propertyOpen); EnumFacing.Axis playerFacing; - if (playerPos.north().equals(doorPos) || playerPos.south().equals(doorPos)) { + if (playerPos.north().equals(blockPos) || playerPos.south().equals(blockPos)) { playerFacing = EnumFacing.Axis.Z; - } else if (playerPos.east().equals(doorPos) || playerPos.west().equals(doorPos)) { + } else if (playerPos.east().equals(blockPos) || playerPos.west().equals(blockPos)) { playerFacing = EnumFacing.Axis.X; } else { return true; diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java index c784f07b..e92fc527 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java @@ -26,10 +26,7 @@ import baritone.pathing.movement.MovementState; import baritone.utils.BlockStateInterface; import baritone.utils.InputOverrideHandler; import baritone.utils.Utils; -import net.minecraft.block.Block; -import net.minecraft.block.BlockDoor; -import net.minecraft.block.BlockLadder; -import net.minecraft.block.BlockVine; +import net.minecraft.block.*; import net.minecraft.block.state.IBlockState; import net.minecraft.client.Minecraft; import net.minecraft.init.Blocks; @@ -145,17 +142,17 @@ public class MovementTraverse extends Movement { boolean ladder = fd instanceof BlockLadder || fd instanceof BlockVine; IBlockState pb0 = BlockStateInterface.get(positionsToBreak[0]); IBlockState pb1 = BlockStateInterface.get(positionsToBreak[1]); - boolean door = BlockStateInterface.get(src).getBlock() instanceof BlockDoor || pb0.getBlock() instanceof BlockDoor || pb1.getBlock() instanceof BlockDoor; + + boolean door = pb0.getBlock() instanceof BlockDoor || pb1.getBlock() instanceof BlockDoor; if (door) { boolean isDoorActuallyBlockingUs = false; - Block srcBlock = BlockStateInterface.get(src).getBlock(); - if (srcBlock instanceof BlockDoor && !MovementHelper.isDoorPassable(src, dest)) { + if (pb0.getBlock() instanceof BlockDoor && !MovementHelper.isDoorPassable(src, dest)) { isDoorActuallyBlockingUs = true; } else if (pb1.getBlock() instanceof BlockDoor && !MovementHelper.isDoorPassable(dest, src)) { isDoorActuallyBlockingUs = true; } if (isDoorActuallyBlockingUs) { - if (!(Blocks.IRON_DOOR.equals(srcBlock) || Blocks.IRON_DOOR.equals(pb0.getBlock()) || Blocks.IRON_DOOR.equals(pb1.getBlock()))) { + if (!(Blocks.IRON_DOOR.equals(pb0.getBlock()) || Blocks.IRON_DOOR.equals(pb1.getBlock()))) { state.setTarget(new MovementState.MovementTarget(Utils.calcRotationFromVec3d(playerHead(), Utils.calcCenterFromCoords(positionsToBreak[0], world())), true)); state.setInput(InputOverrideHandler.Input.CLICK_RIGHT, true); return state; @@ -163,6 +160,21 @@ public class MovementTraverse extends Movement { } } + if (pb0.getBlock() instanceof BlockFenceGate || pb1.getBlock() instanceof BlockFenceGate) { + BlockPos blocked = null; + if (!MovementHelper.isGatePassable(positionsToBreak[0], src.up())) { + blocked = positionsToBreak[0]; + } else if (!MovementHelper.isGatePassable(positionsToBreak[1], src)) { + blocked = positionsToBreak[1]; + } + + if (blocked != null) { + state.setTarget(new MovementState.MovementTarget(Utils.calcRotationFromVec3d(playerHead(), Utils.calcCenterFromCoords(blocked, world())), true)); + state.setInput(InputOverrideHandler.Input.CLICK_RIGHT, true); + return state; + } + } + boolean isTheBridgeBlockThere = MovementHelper.canWalkOn(positionsToPlace[0]) || ladder; BlockPos whereAmI = playerFeet(); if (whereAmI.getY() != dest.getY() && !ladder) { From 5c7ffe6ed16d2610d06427d84966e3d57d54a4ea Mon Sep 17 00:00:00 2001 From: Brady Date: Sun, 26 Aug 2018 02:25:13 -0500 Subject: [PATCH 73/86] Removed irrelevant TODO --- .../java/baritone/pathing/movement/movements/MovementFall.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/baritone/pathing/movement/movements/MovementFall.java b/src/main/java/baritone/pathing/movement/movements/MovementFall.java index 707a997b..5c40c706 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementFall.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementFall.java @@ -92,7 +92,7 @@ public class MovementFall extends Movement { BlockPos playerFeet = playerFeet(); Rotation targetRotation = null; if (!BlockStateInterface.isWater(dest) && src.getY() - dest.getY() > Baritone.settings().maxFallHeightNoWater.get() && !playerFeet.equals(dest)) { - if (!player().inventory.hasItemStack(STACK_BUCKET_WATER) || world().provider.isNether()) { // TODO check if water bucket is on hotbar or main inventory + if (!player().inventory.hasItemStack(STACK_BUCKET_WATER) || world().provider.isNether()) { state.setStatus(MovementStatus.UNREACHABLE); return state; } From 50fd63647b4f0481e362ed45780cb6cfd797aee5 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 26 Aug 2018 08:12:57 -0700 Subject: [PATCH 74/86] sprint through descend, fixes #29 and #38 --- src/main/java/baritone/Settings.java | 7 +++ .../baritone/pathing/movement/Movement.java | 5 +- .../pathing/movement/MovementHelper.java | 2 +- .../movement/movements/MovementDiagonal.java | 6 +- .../movement/movements/MovementTraverse.java | 5 +- .../baritone/pathing/path/PathExecutor.java | 57 +++++++++++++++++++ 6 files changed, 74 insertions(+), 8 deletions(-) diff --git a/src/main/java/baritone/Settings.java b/src/main/java/baritone/Settings.java index e596df14..a23401dc 100644 --- a/src/main/java/baritone/Settings.java +++ b/src/main/java/baritone/Settings.java @@ -147,6 +147,13 @@ public class Settings { */ public Setting maxFallHeightBucket = new Setting<>(20); + /** + * Is it okay to sprint through a descend followed by a diagonal? + * The player overshoots the landing, but not enough to fall off. And the diagonal ensures that there isn't + * lava or anything that's !canWalkInto in that space, so it's technically safe, just a little sketchy. + */ + public Setting allowOvershootDiagonalDescend = new Setting<>(true); + /** * If your goal is a GoalBlock in an unloaded chunk, assume it's far enough away that the Y coord * doesn't matter yet, and replace it with a GoalXZ to the same place before calculating a path. diff --git a/src/main/java/baritone/pathing/movement/Movement.java b/src/main/java/baritone/pathing/movement/Movement.java index 27cbb08e..5a3f26f5 100644 --- a/src/main/java/baritone/pathing/movement/Movement.java +++ b/src/main/java/baritone/pathing/movement/Movement.java @@ -104,7 +104,6 @@ public abstract class Movement implements Helper, MovementHelper { * @return Status */ public MovementStatus update() { - player().setSprinting(false); MovementState latestState = updateState(currentState); if (BlockStateInterface.isLiquid(playerFeet())) { latestState.setInput(Input.JUMP, true); @@ -269,6 +268,10 @@ public abstract class Movement implements Helper, MovementHelper { return state; } + public BlockPos getDirection() { + return getDest().subtract(getSrc()); + } + public List toBreakCached = null; public List toPlaceCached = null; public List toWalkIntoCached = null; diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java index 34c65ae6..fd033b78 100644 --- a/src/main/java/baritone/pathing/movement/MovementHelper.java +++ b/src/main/java/baritone/pathing/movement/MovementHelper.java @@ -158,7 +158,7 @@ public interface MovementHelper extends ActionCosts, Helper { return true; } - return (facing == playerFacing) == open; + return facing == playerFacing == open; } static boolean avoidWalkingInto(Block block) { diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java index 7bde41c7..cd29bdbf 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java @@ -17,12 +17,12 @@ package baritone.pathing.movement.movements; -import baritone.Baritone; import baritone.pathing.movement.CalculationContext; import baritone.pathing.movement.Movement; import baritone.pathing.movement.MovementHelper; import baritone.pathing.movement.MovementState; import baritone.utils.BlockStateInterface; +import baritone.utils.InputOverrideHandler; import net.minecraft.block.BlockMagma; import net.minecraft.block.state.IBlockState; import net.minecraft.init.Blocks; @@ -65,8 +65,8 @@ public class MovementDiagonal extends Movement { state.setStatus(MovementState.MovementStatus.SUCCESS); return state; } - if (!BlockStateInterface.isLiquid(playerFeet()) && Baritone.settings().allowSprint.get()) { - player().setSprinting(true); + if (!BlockStateInterface.isLiquid(playerFeet())) { + state.setInput(InputOverrideHandler.Input.SPRINT, true); } MovementHelper.moveTowards(state, dest); return state; diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java index e92fc527..20b284e6 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java @@ -17,7 +17,6 @@ package baritone.pathing.movement.movements; -import baritone.Baritone; import baritone.behavior.impl.LookBehaviorUtils; import baritone.pathing.movement.CalculationContext; import baritone.pathing.movement.Movement; @@ -190,8 +189,8 @@ public class MovementTraverse extends Movement { state.setStatus(MovementState.MovementStatus.SUCCESS); return state; } - if (wasTheBridgeBlockAlwaysThere && !BlockStateInterface.isLiquid(playerFeet()) && Baritone.settings().allowSprint.get()) { - player().setSprinting(true); + if (wasTheBridgeBlockAlwaysThere && !BlockStateInterface.isLiquid(playerFeet())) { + state.setInput(InputOverrideHandler.Input.SPRINT, true); } Block destDown = BlockStateInterface.get(dest.down()).getBlock(); if (ladder && (destDown instanceof BlockVine || destDown instanceof BlockLadder)) { diff --git a/src/main/java/baritone/pathing/path/PathExecutor.java b/src/main/java/baritone/pathing/path/PathExecutor.java index 88a7126c..210544c4 100644 --- a/src/main/java/baritone/pathing/path/PathExecutor.java +++ b/src/main/java/baritone/pathing/path/PathExecutor.java @@ -22,6 +22,9 @@ import baritone.event.events.TickEvent; import baritone.pathing.movement.ActionCosts; import baritone.pathing.movement.Movement; import baritone.pathing.movement.MovementState; +import baritone.pathing.movement.movements.MovementDescend; +import baritone.pathing.movement.movements.MovementDiagonal; +import baritone.pathing.movement.movements.MovementTraverse; import baritone.utils.BlockStateInterface; import baritone.utils.Helper; import net.minecraft.client.entity.EntityPlayerSP; @@ -228,6 +231,7 @@ public class PathExecutor implements Helper { onTick(event); return true; } else { + sprintIfRequested(); ticksOnCurrent++; if (ticksOnCurrent > currentMovementInitialCostEstimate + Baritone.settings().movementTimeoutTicks.get()) { // only fail if the total time has exceeded the initial estimate @@ -245,6 +249,59 @@ public class PathExecutor implements Helper { return false; // movement is in progress } + private void sprintIfRequested() { + if (!Baritone.settings().allowSprint.get()) { + player().setSprinting(false); + return; + } + if (Baritone.INSTANCE.getInputOverrideHandler().isInputForcedDown(mc.gameSettings.keyBindSprint)) { + if (!player().isSprinting()) { + player().setSprinting(true); + } + return; + } + Movement movement = path.movements().get(pathPosition); + if (movement instanceof MovementDescend && pathPosition < path.length() - 2) { + Movement next = path.movements().get(pathPosition + 1); + if (next instanceof MovementDescend) { + if (next.getDirection().equals(movement.getDirection())) { + if (playerFeet().equals(movement.getDest())) { + pathPosition++; + Baritone.INSTANCE.getInputOverrideHandler().clearAllKeys(); + } + if (!player().isSprinting()) { + player().setSprinting(true); + } + return; + } + } + if (next instanceof MovementTraverse) { + if (next.getDirection().down().equals(movement.getDirection())) { + if (playerFeet().equals(movement.getDest())) { + pathPosition++; + Baritone.INSTANCE.getInputOverrideHandler().clearAllKeys(); + } + if (!player().isSprinting()) { + player().setSprinting(true); + } + return; + } + } + if (next instanceof MovementDiagonal && Baritone.settings().allowOvershootDiagonalDescend.get()) { + if (playerFeet().equals(movement.getDest())) { + pathPosition++; + Baritone.INSTANCE.getInputOverrideHandler().clearAllKeys(); + } + if (!player().isSprinting()) { + player().setSprinting(true); + } + return; + } + displayChatMessageRaw("Turning off sprinting " + movement + " " + next + " " + movement.getDirection() + " " + next.getDirection().down() + " " + next.getDirection().down().equals(movement.getDirection())); + } + player().setSprinting(false); + } + public int getPosition() { return pathPosition; } From 6dd501a46bbba8710bd8bea524f6c2bf13987996 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 26 Aug 2018 08:19:14 -0700 Subject: [PATCH 75/86] add cost verification lookahead --- src/main/java/baritone/Settings.java | 7 +++++++ src/main/java/baritone/pathing/path/PathExecutor.java | 9 +++++++++ 2 files changed, 16 insertions(+) diff --git a/src/main/java/baritone/Settings.java b/src/main/java/baritone/Settings.java index a23401dc..9b918416 100644 --- a/src/main/java/baritone/Settings.java +++ b/src/main/java/baritone/Settings.java @@ -119,6 +119,13 @@ public class Settings { */ public Setting cutoffAtLoadBoundary = new Setting<>(true); + /** + * Stop 5 movements before anything that made the path COST_INF. + * For example, if lava has spread across the path, don't walk right up to it then recalculate, it might + * still be spreading lol + */ + public Setting costVerificationLookahead = new Setting<>(5); + /** * Static cutoff factor. 0.9 means cut off the last 10% of all paths, regardless of chunk load state */ diff --git a/src/main/java/baritone/pathing/path/PathExecutor.java b/src/main/java/baritone/pathing/path/PathExecutor.java index 210544c4..75bebc8a 100644 --- a/src/main/java/baritone/pathing/path/PathExecutor.java +++ b/src/main/java/baritone/pathing/path/PathExecutor.java @@ -211,6 +211,15 @@ public class PathExecutor implements Helper { Baritone.INSTANCE.getInputOverrideHandler().clearAllKeys(); return true; } + for (int i = 1; i < Baritone.settings().costVerificationLookahead.get() && pathPosition + i < path.length() - 1; i++) { + if (path.movements().get(pathPosition + 1).recalculateCost() >= ActionCosts.COST_INF) { + displayChatMessageRaw("Something has changed in the world and a future movement has become impossible. Cancelling."); + pathPosition = path.length() + 3; + failed = true; + Baritone.INSTANCE.getInputOverrideHandler().clearAllKeys(); + return true; + } + } if (costEstimateIndex == null || costEstimateIndex != pathPosition) { costEstimateIndex = pathPosition; currentMovementInitialCostEstimate = currentCost; // do this only once, when the movement starts From e8c644fc6321d9a20c61999aba65f087823c8537 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 26 Aug 2018 08:22:34 -0700 Subject: [PATCH 76/86] haha --- src/main/java/baritone/pathing/path/PathExecutor.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/baritone/pathing/path/PathExecutor.java b/src/main/java/baritone/pathing/path/PathExecutor.java index 75bebc8a..1dbaf4fb 100644 --- a/src/main/java/baritone/pathing/path/PathExecutor.java +++ b/src/main/java/baritone/pathing/path/PathExecutor.java @@ -212,7 +212,7 @@ public class PathExecutor implements Helper { return true; } for (int i = 1; i < Baritone.settings().costVerificationLookahead.get() && pathPosition + i < path.length() - 1; i++) { - if (path.movements().get(pathPosition + 1).recalculateCost() >= ActionCosts.COST_INF) { + if (path.movements().get(pathPosition + i).recalculateCost() >= ActionCosts.COST_INF) { displayChatMessageRaw("Something has changed in the world and a future movement has become impossible. Cancelling."); pathPosition = path.length() + 3; failed = true; From 5f6a5ea4030386286d83b2b95532b1b73bfb3d32 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 26 Aug 2018 08:31:03 -0700 Subject: [PATCH 77/86] extend MovementFall breakability one more, fixes #97 --- .../pathing/movement/MovementHelper.java | 18 +++++++++--------- .../movement/movements/MovementFall.java | 13 ++++++++----- 2 files changed, 17 insertions(+), 14 deletions(-) diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java index fd033b78..93bd34fb 100644 --- a/src/main/java/baritone/pathing/movement/MovementHelper.java +++ b/src/main/java/baritone/pathing/movement/MovementHelper.java @@ -304,22 +304,22 @@ public interface MovementHelper extends ActionCosts, Helper { static Movement generateMovementFallOrDescend(BlockPos pos, BlockPos dest, CalculationContext calcContext) { // A //SA - // B + // A // B // C // D - //if S is where you start, both of B need to be air for a movementfall + //if S is where you start, B needs to be air for a movementfall //A is plausibly breakable by either descend or fall //C, D, etc determine the length of the fall - for (int i = 1; i < 3; i++) { - if (!canWalkThrough(dest.down(i))) { - //if any of these two (B in the diagram) aren't air - //have to do a descend, because fall is impossible - //this doesn't guarantee descend is possible, it just guarantees fall is impossible - return new MovementDescend(pos, dest.down()); // standard move out by 1 and descend by 1 - } + if (!canWalkThrough(dest.down(2))) { + //if B in the diagram aren't air + //have to do a descend, because fall is impossible + + //this doesn't guarantee descend is possible, it just guarantees fall is impossible + return new MovementDescend(pos, dest.down()); // standard move out by 1 and descend by 1 } + // we're clear for a fall 2 // let's see how far we can fall for (int fallHeight = 3; true; fallHeight++) { diff --git a/src/main/java/baritone/pathing/movement/movements/MovementFall.java b/src/main/java/baritone/pathing/movement/movements/MovementFall.java index 5c40c706..04e42938 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementFall.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementFall.java @@ -56,14 +56,17 @@ public class MovementFall extends Movement { } placeBucketCost = context.placeBlockCost(); } - double frontTwo = MovementHelper.getMiningDurationTicks(context, positionsToBreak[0]) + MovementHelper.getMiningDurationTicks(context, positionsToBreak[1]); - if (frontTwo >= COST_INF) { - return COST_INF; + double frontThree = 0; + for (int i = 0; i < 3; i++) { + frontThree += MovementHelper.getMiningDurationTicks(context, positionsToBreak[i]); + if (frontThree >= COST_INF) { + return COST_INF; + } } if (BlockStateInterface.get(positionsToBreak[0].up()).getBlock() instanceof BlockFalling) { return COST_INF; } - for (int i = 2; i < positionsToBreak.length; i++) { + for (int i = 3; i < positionsToBreak.length; i++) { // TODO is this the right check here? // MiningDurationTicks is all right, but shouldn't it be canWalkThrough instead? // Lilypads (i think?) are 0 ticks to mine, but they definitely cause fall damage @@ -74,7 +77,7 @@ public class MovementFall extends Movement { return COST_INF; } } - return WALK_OFF_BLOCK_COST + FALL_N_BLOCKS_COST[positionsToBreak.length - 1] + placeBucketCost + frontTwo; + return WALK_OFF_BLOCK_COST + FALL_N_BLOCKS_COST[positionsToBreak.length - 1] + placeBucketCost + frontThree; } @Override From f95e35de0a17b91ee58c11bd24e75d6939833bc9 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 26 Aug 2018 08:45:02 -0700 Subject: [PATCH 78/86] rudimentary setup readme --- README.md | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index ea844c28..5d5d9c47 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,10 @@ # Baritone A Minecraft bot. This project is an updated version of [Minebot](https://github.com/leijurv/MineBot/), -the original version of the bot for Minecraft 1.8, rebuilt for 1.12.2. \ No newline at end of file +the original version of the bot for Minecraft 1.8, rebuilt for 1.12.2. + +# Setup +- Open the project in IntelliJ as a Gradle project +- Run the Gradle task `setupDecompWorkspace` +- Run the Gradle task `genIntellijRuns` +- Restart IntelliJ and import Gradle changes +- Select the "Minecraft Client" launch config and run \ No newline at end of file From 9a24e6a1a3ecdba0cd20d9818800b00e7cffefd4 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 26 Aug 2018 08:49:56 -0700 Subject: [PATCH 79/86] fixed overzealous cost check --- .../baritone/pathing/path/PathExecutor.java | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/main/java/baritone/pathing/path/PathExecutor.java b/src/main/java/baritone/pathing/path/PathExecutor.java index 1dbaf4fb..504e9ecb 100644 --- a/src/main/java/baritone/pathing/path/PathExecutor.java +++ b/src/main/java/baritone/pathing/path/PathExecutor.java @@ -211,18 +211,18 @@ public class PathExecutor implements Helper { Baritone.INSTANCE.getInputOverrideHandler().clearAllKeys(); return true; } - for (int i = 1; i < Baritone.settings().costVerificationLookahead.get() && pathPosition + i < path.length() - 1; i++) { - if (path.movements().get(pathPosition + i).recalculateCost() >= ActionCosts.COST_INF) { - displayChatMessageRaw("Something has changed in the world and a future movement has become impossible. Cancelling."); - pathPosition = path.length() + 3; - failed = true; - Baritone.INSTANCE.getInputOverrideHandler().clearAllKeys(); - return true; - } - } if (costEstimateIndex == null || costEstimateIndex != pathPosition) { costEstimateIndex = pathPosition; currentMovementInitialCostEstimate = currentCost; // do this only once, when the movement starts + for (int i = 1; i < Baritone.settings().costVerificationLookahead.get() && pathPosition + i < path.length() - 1; i++) { + if (path.movements().get(pathPosition + i).recalculateCost() >= ActionCosts.COST_INF) { + displayChatMessageRaw("Something has changed in the world and a future movement has become impossible. Cancelling."); + pathPosition = path.length() + 3; + failed = true; + Baritone.INSTANCE.getInputOverrideHandler().clearAllKeys(); + return true; + } + } } MovementState.MovementStatus movementStatus = movement.update(); if (movementStatus == UNREACHABLE || movementStatus == FAILED) { From 45631fa12add1479203534acb168e6044020cf72 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 26 Aug 2018 08:50:30 -0700 Subject: [PATCH 80/86] brady pls --- src/main/java/baritone/chunk/CachedRegion.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/baritone/chunk/CachedRegion.java b/src/main/java/baritone/chunk/CachedRegion.java index 923edc16..d8484ecd 100644 --- a/src/main/java/baritone/chunk/CachedRegion.java +++ b/src/main/java/baritone/chunk/CachedRegion.java @@ -231,7 +231,7 @@ public final class CachedRegion implements IBlockTypeAccess { if (tmpCached[x][z] != null) { // 16 * 16 * 256 = 65536 so a short is enough // ^ haha jokes on leijurv, java doesn't have unsigned types so that isn't correct - // also ur gay if u have more than 32767 special blocks in a chunk + // also why would you have more than 32767 special blocks in a chunk short numSpecialBlockTypes = in.readShort(); for (int i = 0; i < numSpecialBlockTypes; i++) { String blockName = in.readUTF(); From 6408e678ff44daa4a3548f6cd6e130f937a626c9 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 26 Aug 2018 08:51:56 -0700 Subject: [PATCH 81/86] fix short int conversion --- src/main/java/baritone/chunk/CachedRegion.java | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/src/main/java/baritone/chunk/CachedRegion.java b/src/main/java/baritone/chunk/CachedRegion.java index d8484ecd..e6aa4198 100644 --- a/src/main/java/baritone/chunk/CachedRegion.java +++ b/src/main/java/baritone/chunk/CachedRegion.java @@ -232,12 +232,19 @@ public final class CachedRegion implements IBlockTypeAccess { // 16 * 16 * 256 = 65536 so a short is enough // ^ haha jokes on leijurv, java doesn't have unsigned types so that isn't correct // also why would you have more than 32767 special blocks in a chunk - short numSpecialBlockTypes = in.readShort(); + // haha double jokes on you now it works for 65535 not just 32767 + int numSpecialBlockTypes = in.readShort(); + if (numSpecialBlockTypes < 0) { + numSpecialBlockTypes += 65536; + } for (int i = 0; i < numSpecialBlockTypes; i++) { String blockName = in.readUTF(); List locs = new ArrayList<>(); location[x][z].put(blockName, locs); - short numLocations = in.readShort(); + int numLocations = in.readShort(); + if (numLocations < 0) { + numLocations += 65536; + } for (int j = 0; j < numLocations; j++) { byte xz = in.readByte(); int X = xz & 0x0f; From 68c2537d20589044c3c62f9c6e6091c24ad27226 Mon Sep 17 00:00:00 2001 From: Brady Date: Sun, 26 Aug 2018 12:09:23 -0500 Subject: [PATCH 82/86] Leijurv doesn't know how unsigned works in java --- src/main/java/baritone/chunk/CachedRegion.java | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) diff --git a/src/main/java/baritone/chunk/CachedRegion.java b/src/main/java/baritone/chunk/CachedRegion.java index e6aa4198..d4a25834 100644 --- a/src/main/java/baritone/chunk/CachedRegion.java +++ b/src/main/java/baritone/chunk/CachedRegion.java @@ -233,18 +233,12 @@ public final class CachedRegion implements IBlockTypeAccess { // ^ haha jokes on leijurv, java doesn't have unsigned types so that isn't correct // also why would you have more than 32767 special blocks in a chunk // haha double jokes on you now it works for 65535 not just 32767 - int numSpecialBlockTypes = in.readShort(); - if (numSpecialBlockTypes < 0) { - numSpecialBlockTypes += 65536; - } + int numSpecialBlockTypes = in.readShort() & 0xffff; for (int i = 0; i < numSpecialBlockTypes; i++) { String blockName = in.readUTF(); List locs = new ArrayList<>(); location[x][z].put(blockName, locs); - int numLocations = in.readShort(); - if (numLocations < 0) { - numLocations += 65536; - } + int numLocations = in.readShort() & 0xffff; for (int j = 0; j < numLocations; j++) { byte xz = in.readByte(); int X = xz & 0x0f; From f052c91cda5f5c4bbfcf38eaed085df92750d29b Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 26 Aug 2018 12:54:01 -0700 Subject: [PATCH 83/86] map 0 to 65536 --- src/main/java/baritone/chunk/CachedRegion.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/main/java/baritone/chunk/CachedRegion.java b/src/main/java/baritone/chunk/CachedRegion.java index d4a25834..0fbe8b4e 100644 --- a/src/main/java/baritone/chunk/CachedRegion.java +++ b/src/main/java/baritone/chunk/CachedRegion.java @@ -239,6 +239,10 @@ public final class CachedRegion implements IBlockTypeAccess { List locs = new ArrayList<>(); location[x][z].put(blockName, locs); int numLocations = in.readShort() & 0xffff; + if (numLocations == 0) { + // an entire chunk full of air can happen in the end + numLocations = 65536; + } for (int j = 0; j < numLocations; j++) { byte xz = in.readByte(); int X = xz & 0x0f; From 74916dd24ed1c7a755f220db9c92ce9047681afb Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 26 Aug 2018 13:09:20 -0700 Subject: [PATCH 84/86] consistency between byte and short read methods --- src/main/java/baritone/chunk/CachedRegion.java | 5 +---- src/test/java/baritone/chunk/CachedRegionTest.java | 5 +---- 2 files changed, 2 insertions(+), 8 deletions(-) diff --git a/src/main/java/baritone/chunk/CachedRegion.java b/src/main/java/baritone/chunk/CachedRegion.java index 0fbe8b4e..7d2ed3dc 100644 --- a/src/main/java/baritone/chunk/CachedRegion.java +++ b/src/main/java/baritone/chunk/CachedRegion.java @@ -247,10 +247,7 @@ public final class CachedRegion implements IBlockTypeAccess { byte xz = in.readByte(); int X = xz & 0x0f; int Z = (xz >>> 4) & 0x0f; - int Y = (int) in.readByte(); - if (Y < 0) { - Y += 256; - } + int Y = in.readByte() & 0xff; locs.add(new BlockPos(X, Y, Z)); } } diff --git a/src/test/java/baritone/chunk/CachedRegionTest.java b/src/test/java/baritone/chunk/CachedRegionTest.java index 0992cee1..8350390c 100644 --- a/src/test/java/baritone/chunk/CachedRegionTest.java +++ b/src/test/java/baritone/chunk/CachedRegionTest.java @@ -33,10 +33,7 @@ public class CachedRegionTest { byte xz = part1; int X = xz & 0x0f; int Z = (xz >>> 4) & 0x0f; - int Y = (int) part2; - if (Y < 0) { - Y += 256; - } + int Y = part2 & 0xff; if (x != X || y != Y || z != Z) { System.out.println(x + " " + X + " " + y + " " + Y + " " + z + " " + Z); } From 5abadc6fe50884afdc8da3a2d0be5cbf8307214f Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 26 Aug 2018 13:48:08 -0700 Subject: [PATCH 85/86] address cost calculation of blockfalling stacks --- .../baritone/pathing/movement/Movement.java | 69 +++++++++++-------- .../pathing/movement/MovementHelper.java | 18 +++-- .../movement/movements/MovementDiagonal.java | 4 +- .../movement/movements/MovementDownward.java | 3 +- .../movement/movements/MovementFall.java | 5 +- 5 files changed, 62 insertions(+), 37 deletions(-) diff --git a/src/main/java/baritone/pathing/movement/Movement.java b/src/main/java/baritone/pathing/movement/Movement.java index 5a3f26f5..11a88ad1 100644 --- a/src/main/java/baritone/pathing/movement/Movement.java +++ b/src/main/java/baritone/pathing/movement/Movement.java @@ -33,6 +33,7 @@ import net.minecraft.util.math.RayTraceResult; import net.minecraft.util.math.Vec3d; import java.util.ArrayList; +import java.util.Arrays; import java.util.List; import java.util.Optional; @@ -214,39 +215,53 @@ public abstract class Movement implements Helper, MovementHelper { } public double getTotalHardnessOfBlocksToBreak(CalculationContext ctx) { - /* - double sum = 0; - HashSet toBreak = new HashSet(); - for (BlockPos positionsToBreak1 : positionsToBreak) { - toBreak.add(positionsToBreak1); - if (this instanceof ActionFall) {//if we are digging straight down, assume we have already broken the sand above us - continue; - } - BlockPos tmp = positionsToBreak1.up(); - while (canFall(tmp)) { - toBreak.add(tmp); - tmp = tmp.up(); - } + if (positionsToBreak.length == 0) { + return 0; } - for (BlockPos pos : toBreak) { - sum += getHardness(ts, Baritone.get(pos), pos); - if (sum >= COST_INF) { - return COST_INF; - } + if (positionsToBreak.length == 1) { + return MovementHelper.getMiningDurationTicks(ctx, positionsToBreak[0], true); } - if (!Baritone.allowBreakOrPlace || !Baritone.hasThrowaway) { - for (int i = 0; i < blocksToPlace.length; i++) { - if (!canWalkOn(positionsToPlace[i])) { - return COST_INF; + int firstColumnX = positionsToBreak[0].getX(); + int firstColumnZ = positionsToBreak[0].getZ(); + int firstColumnMaxY = positionsToBreak[0].getY(); + int firstColumnMaximalIndex = 0; + boolean hasSecondColumn = false; + int secondColumnX = -1; + int secondColumnZ = -1; + int secondColumnMaxY = -1; + int secondColumnMaximalIndex = -1; + for (int i = 0; i < positionsToBreak.length; i++) { + BlockPos pos = positionsToBreak[i]; + if (pos.getX() == firstColumnX && pos.getZ() == firstColumnZ) { + if (pos.getY() > firstColumnMaxY) { + firstColumnMaxY = pos.getY(); + firstColumnMaximalIndex = i; + } + } else { + if (!hasSecondColumn || (pos.getX() == secondColumnX && pos.getZ() == secondColumnZ)) { + if (hasSecondColumn) { + if (pos.getY() > secondColumnMaxY) { + secondColumnMaxY = pos.getY(); + secondColumnMaximalIndex = i; + } + } else { + hasSecondColumn = true; + secondColumnX = pos.getX(); + secondColumnZ = pos.getZ(); + secondColumnMaxY = pos.getY(); + secondColumnMaximalIndex = i; + } + } else { + throw new IllegalStateException("I literally have no idea " + Arrays.asList(positionsToBreak)); } } - }*/ - //^ the above implementation properly deals with falling blocks, TODO integrate + } + double sum = 0; - for (BlockPos pos : positionsToBreak) { - sum += MovementHelper.getMiningDurationTicks(ctx, pos); + for (int i = 0; i < positionsToBreak.length; i++) { + sum += MovementHelper.getMiningDurationTicks(ctx, positionsToBreak[i], firstColumnMaximalIndex == i || secondColumnMaximalIndex == i); if (sum >= COST_INF) { - return COST_INF; + break; } } return sum; diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java index 93bd34fb..549ee621 100644 --- a/src/main/java/baritone/pathing/movement/MovementHelper.java +++ b/src/main/java/baritone/pathing/movement/MovementHelper.java @@ -208,12 +208,12 @@ public interface MovementHelper extends ActionCosts, Helper { return BlockStateInterface.get(pos).getBlock() instanceof BlockFalling; } - static double getMiningDurationTicks(CalculationContext context, BlockPos position) { + static double getMiningDurationTicks(CalculationContext context, BlockPos position, boolean includeFalling) { IBlockState state = BlockStateInterface.get(position); - return getMiningDurationTicks(context, position, state); + return getMiningDurationTicks(context, position, state, includeFalling); } - static double getMiningDurationTicks(CalculationContext context, BlockPos position, IBlockState state) { + static double getMiningDurationTicks(CalculationContext context, BlockPos position, IBlockState state, boolean includeFalling) { Block block = state.getBlock(); if (!block.equals(Blocks.AIR) && !canWalkThrough(position, state)) { // TODO is the air check really necessary? Isn't air canWalkThrough? if (!context.allowBreak()) { @@ -223,9 +223,17 @@ public interface MovementHelper extends ActionCosts, Helper { return COST_INF; } double m = Blocks.CRAFTING_TABLE.equals(block) ? 10 : 1; // TODO see if this is still necessary. it's from MineBot when we wanted to penalize breaking its crafting table - return m / context.getToolSet().getStrVsBlock(state, position); + double result = m / context.getToolSet().getStrVsBlock(state, position); + if (includeFalling) { + BlockPos up = position.up(); + IBlockState above = BlockStateInterface.get(up); + if (above.getBlock() instanceof BlockFalling) { + result += getMiningDurationTicks(context, up, above, true); + } + } + return result; } - return 0; + return 0; // we won't actually mine it, so don't check fallings above } /** diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java index cd29bdbf..20defe13 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java @@ -97,8 +97,8 @@ public class MovementDiagonal extends Movement { if (BlockStateInterface.get(positionsToBreak[4].down()).getBlock() instanceof BlockMagma) { return COST_INF; } - double optionA = MovementHelper.getMiningDurationTicks(context, positionsToBreak[0]) + MovementHelper.getMiningDurationTicks(context, positionsToBreak[1]); - double optionB = MovementHelper.getMiningDurationTicks(context, positionsToBreak[2]) + MovementHelper.getMiningDurationTicks(context, positionsToBreak[3]); + double optionA = MovementHelper.getMiningDurationTicks(context, positionsToBreak[0], false) + MovementHelper.getMiningDurationTicks(context, positionsToBreak[1], true); + double optionB = MovementHelper.getMiningDurationTicks(context, positionsToBreak[2], false) + MovementHelper.getMiningDurationTicks(context, positionsToBreak[3], true); if (optionA != 0 && optionB != 0) { return COST_INF; } diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDownward.java b/src/main/java/baritone/pathing/movement/movements/MovementDownward.java index 724b8688..38232396 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementDownward.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementDownward.java @@ -53,7 +53,8 @@ public class MovementDownward extends Movement { if (ladder) { return LADDER_DOWN_ONE_COST; } else { - return FALL_N_BLOCKS_COST[1] + MovementHelper.getMiningDurationTicks(context, dest, d); + // we're standing on it, while it might be block falling, it'll be air by the time we get here in the movement + return FALL_N_BLOCKS_COST[1] + MovementHelper.getMiningDurationTicks(context, dest, d, false); } } diff --git a/src/main/java/baritone/pathing/movement/movements/MovementFall.java b/src/main/java/baritone/pathing/movement/movements/MovementFall.java index 04e42938..c42a8661 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementFall.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementFall.java @@ -58,7 +58,8 @@ public class MovementFall extends Movement { } double frontThree = 0; for (int i = 0; i < 3; i++) { - frontThree += MovementHelper.getMiningDurationTicks(context, positionsToBreak[i]); + frontThree += MovementHelper.getMiningDurationTicks(context, positionsToBreak[i], false); + // don't include falling because we will check falling right after this, and if it's there it's COST_INF if (frontThree >= COST_INF) { return COST_INF; } @@ -72,7 +73,7 @@ public class MovementFall extends Movement { // Lilypads (i think?) are 0 ticks to mine, but they definitely cause fall damage // Same thing for falling through water... we can't actually do that // And falling through signs is possible, but they do have a mining duration, right? - if (MovementHelper.getMiningDurationTicks(context, positionsToBreak[i]) > 0) { + if (MovementHelper.getMiningDurationTicks(context, positionsToBreak[i], false) > 0) { //can't break while falling return COST_INF; } From 3bb1c1a972a50232956c05a4d6498d1500a3f929 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 26 Aug 2018 13:51:50 -0700 Subject: [PATCH 86/86] unneeded --- src/main/java/baritone/pathing/path/PathExecutor.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/baritone/pathing/path/PathExecutor.java b/src/main/java/baritone/pathing/path/PathExecutor.java index 504e9ecb..0e7ebec6 100644 --- a/src/main/java/baritone/pathing/path/PathExecutor.java +++ b/src/main/java/baritone/pathing/path/PathExecutor.java @@ -306,7 +306,7 @@ public class PathExecutor implements Helper { } return; } - displayChatMessageRaw("Turning off sprinting " + movement + " " + next + " " + movement.getDirection() + " " + next.getDirection().down() + " " + next.getDirection().down().equals(movement.getDirection())); + //displayChatMessageRaw("Turning off sprinting " + movement + " " + next + " " + movement.getDirection() + " " + next.getDirection().down() + " " + next.getDirection().down().equals(movement.getDirection())); } player().setSprinting(false); }