inventoryMoveOnlyIfStationary = new Setting<>(false);
+
/**
* Disable baritone's auto-tool at runtime, but still assume that another mod will provide auto tool functionality
*
@@ -609,6 +627,13 @@ public final class Settings {
*/
public final Setting pruneRegionsFromRAM = new Setting<>(true);
+ /**
+ * The chunk packer queue can never grow to larger than this, if it does, the oldest chunks are discarded
+ *
+ * The newest chunks are kept, so that if you're moving in a straight line quickly then stop, your immediate render distance is still included
+ */
+ public final Setting chunkPackerQueueMaxSize = new Setting<>(2000);
+
/**
* Fill in blocks behind you
*/
@@ -710,6 +735,37 @@ public final class Settings {
*/
public final Setting freeLook = new Setting<>(true);
+ /**
+ * Break and place blocks without having to force the client-sided rotations. Requires {@link #freeLook}.
+ */
+ public final Setting blockFreeLook = new Setting<>(false);
+
+ /**
+ * Automatically elytra fly without having to force the client-sided rotations.
+ */
+ public final Setting elytraFreeLook = new Setting<>(false);
+
+ /**
+ * Forces the client-sided yaw rotation to an average of the last {@link #smoothLookTicks} of server-sided rotations.
+ */
+ public final Setting smoothLook = new Setting<>(false);
+
+ /**
+ * Same as {@link #smoothLook} but for elytra flying.
+ */
+ public final Setting elytraSmoothLook = new Setting<>(true);
+
+ /**
+ * The number of ticks to average across for {@link #smoothLook};
+ */
+ public final Setting smoothLookTicks = new Setting<>(5);
+
+ /**
+ * When true, the player will remain with its existing look direction as often as possible.
+ * Although, in some cases this can get it stuck, hence this setting to disable that behavior.
+ */
+ public final Setting remainWithExistingLookDirection = new Setting<>(true);
+
/**
* Will cause some minor behavioral differences to ensure that Baritone works on anticheats.
*
@@ -772,6 +828,11 @@ public final class Settings {
*/
public final Setting shortBaritonePrefix = new Setting<>(false);
+ /**
+ * Use a modern message tag instead of a prefix when logging to chat
+ */
+ public final Setting useMessageTag = new Setting<>(false);
+
/**
* Echo commands to chat when they are run
*/
@@ -845,6 +906,11 @@ public final class Settings {
*/
public final Setting minYLevelWhileMining = new Setting<>(0);
+ /**
+ * Sets the maximum y level to mine ores at.
+ */
+ public final Setting maxYLevelWhileMining = new Setting<>(2031);
+
/**
* This will only allow baritone to mine exposed ores, can be used to stop ore obfuscators on servers that use them.
*/
@@ -1141,13 +1207,18 @@ public final class Settings {
* via {@link Consumer#andThen(Consumer)} or it can completely be overriden via setting
* {@link Setting#value};
*/
- public final Setting> logger = new Setting<>(msg -> Minecraft.getInstance().gui.getChat().addMessage(msg));
+ @JavaOnly
+ public final Setting> logger = new Setting<>((msg) -> {
+ final GuiMessageTag tag = useMessageTag.value ? Helper.MESSAGE_TAG : null;
+ Minecraft.getInstance().gui.getChat().addMessage(msg, null, tag);
+ });
/**
* The function that is called when Baritone will send a desktop notification. This function can be added to
* via {@link Consumer#andThen(Consumer)} or it can completely be overriden via setting
* {@link Setting#value};
*/
+ @JavaOnly
public final Setting> notifier = new Setting<>(NotificationHelper::notify);
/**
@@ -1155,6 +1226,7 @@ public final class Settings {
* via {@link Consumer#andThen(Consumer)} or it can completely be overriden via setting
* {@link Setting#value};
*/
+ @JavaOnly
public final Setting> toaster = new Setting<>(BaritoneToast::addOrUpdate);
/**
@@ -1287,6 +1359,115 @@ public final class Settings {
*/
public final Setting notificationOnMineFail = new Setting<>(true);
+ /**
+ * The number of ticks of elytra movement to simulate while firework boost is not active. Higher values are
+ * computationally more expensive.
+ */
+ public final Setting elytraSimulationTicks = new Setting<>(20);
+
+ /**
+ * The maximum allowed deviation in pitch from a direct line-of-sight to the flight target. Higher values are
+ * computationally more expensive.
+ */
+ public final Setting elytraPitchRange = new Setting<>(25);
+
+ /**
+ * The minimum speed that the player can drop to (in blocks/tick) before a firework is automatically deployed.
+ */
+ public final Setting elytraFireworkSpeed = new Setting<>(1.2);
+
+ /**
+ * The delay after the player's position is set-back by the server that a firework may be automatically deployed.
+ * Value is in ticks.
+ */
+ public final Setting elytraFireworkSetbackUseDelay = new Setting<>(15);
+
+ /**
+ * The minimum padding value that is added to the player's hitbox when considering which point to fly to on the
+ * path. High values can result in points not being considered which are otherwise safe to fly to. Low values can
+ * result in flight paths which are extremely tight, and there's the possibility of crashing due to getting too low
+ * to the ground.
+ */
+ public final Setting elytraMinimumAvoidance = new Setting<>(0.2);
+
+ /**
+ * If enabled, avoids using fireworks when descending along the flight path.
+ */
+ public final Setting elytraConserveFireworks = new Setting<>(false);
+
+ /**
+ * Renders the raytraces that are performed by the elytra fly calculation.
+ */
+ public final Setting elytraRenderRaytraces = new Setting<>(false);
+
+ /**
+ * Renders the raytraces that are used in the hitbox part of the elytra fly calculation.
+ * Requires {@link #elytraRenderRaytraces}.
+ */
+ public final Setting elytraRenderHitboxRaytraces = new Setting<>(false);
+
+ /**
+ * Renders the best elytra flight path that was simulated each tick.
+ */
+ public final Setting elytraRenderSimulation = new Setting<>(true);
+
+ /**
+ * Automatically path to and jump off of ledges to initiate elytra flight when grounded.
+ */
+ public final Setting elytraAutoJump = new Setting<>(false);
+
+ /**
+ * The seed used to generate chunks for long distance elytra path-finding in the nether.
+ * Defaults to 2b2t's nether seed.
+ */
+ public final Setting elytraNetherSeed = new Setting<>(146008555100680L);
+
+ /**
+ * Whether nether-pathfinder should generate terrain based on {@link #elytraNetherSeed}.
+ * If false all chunks that haven't been loaded are assumed to be air.
+ */
+ public final Setting elytraPredictTerrain = new Setting<>(true);
+
+ /**
+ * Automatically swap the current elytra with a new one when the durability gets too low
+ */
+ public final Setting elytraAutoSwap = new Setting<>(true);
+
+ /**
+ * The minimum durability an elytra can have before being swapped
+ */
+ public final Setting elytraMinimumDurability = new Setting<>(5);
+
+ /**
+ * The minimum fireworks before landing early for safety
+ */
+ public final Setting elytraMinFireworksBeforeLanding = new Setting<>(5);
+
+ /**
+ * Automatically land when elytra is almost out of durability, or almost out of fireworks
+ */
+ public final Setting elytraAllowEmergencyLand = new Setting<>(true);
+
+ /**
+ * Time between culling far away chunks from the nether pathfinder chunk cache
+ */
+ public final Setting elytraTimeBetweenCacheCullSecs = new Setting<>(TimeUnit.MINUTES.toSeconds(3));
+
+ /**
+ * Maximum distance chunks can be before being culled from the nether pathfinder chunk cache
+ */
+ public final Setting elytraCacheCullDistance = new Setting<>(5000);
+
+ /**
+ * Should elytra consider nether brick a valid landing block
+ */
+ public final Setting elytraAllowLandOnNetherFortress = new Setting<>(false);
+
+ /**
+ * Has the user read and understood the elytra terms and conditions
+ */
+ public final Setting elytraTermsAccepted = new Setting<>(false);
+
/**
* A map of lowercase setting field names to their respective setting
*/
@@ -1304,6 +1485,7 @@ public final class Settings {
public T value;
public final T defaultValue;
private String name;
+ private boolean javaOnly;
@SuppressWarnings("unchecked")
private Setting(T value) {
@@ -1312,6 +1494,7 @@ public final class Settings {
}
this.value = value;
this.defaultValue = value;
+ this.javaOnly = false;
}
/**
@@ -1348,8 +1531,25 @@ public final class Settings {
public final Type getType() {
return settingTypes.get(this);
}
+
+ /**
+ * This should always be the same as whether the setting can be parsed from or serialized to a string; in other
+ * words, the only way to modify it is by writing to {@link #value} programatically.
+ *
+ * @return {@code true} if the setting can not be set or read by the user
+ */
+ public boolean isJavaOnly() {
+ return javaOnly;
+ }
}
+ /**
+ * Marks a {@link Setting} field as being {@link Setting#isJavaOnly() Java-only}
+ */
+ @Retention(RetentionPolicy.RUNTIME)
+ @Target(ElementType.FIELD)
+ private @interface JavaOnly {}
+
// here be dragons
Settings() {
@@ -1365,6 +1565,7 @@ public final class Settings {
Setting setting = (Setting) field.get(this);
String name = field.getName();
setting.name = name;
+ setting.javaOnly = field.isAnnotationPresent(JavaOnly.class);
name = name.toLowerCase();
if (tmpByName.containsKey(name)) {
throw new IllegalStateException("Duplicate setting name");
diff --git a/src/api/java/baritone/api/behavior/ILookBehavior.java b/src/api/java/baritone/api/behavior/ILookBehavior.java
index 058a5dd88..d78e7f8b3 100644
--- a/src/api/java/baritone/api/behavior/ILookBehavior.java
+++ b/src/api/java/baritone/api/behavior/ILookBehavior.java
@@ -17,6 +17,8 @@
package baritone.api.behavior;
+import baritone.api.Settings;
+import baritone.api.behavior.look.IAimProcessor;
import baritone.api.utils.Rotation;
/**
@@ -26,14 +28,23 @@ import baritone.api.utils.Rotation;
public interface ILookBehavior extends IBehavior {
/**
- * Updates the current {@link ILookBehavior} target to target
- * the specified rotations on the next tick. If force is {@code true},
- * then freeLook will be overriden and angles will be set regardless.
- * If any sort of block interaction is required, force should be {@code true},
- * otherwise, it should be {@code false};
+ * Updates the current {@link ILookBehavior} target to target the specified rotations on the next tick. If any sort
+ * of block interaction is required, {@code blockInteract} should be {@code true}. It is not guaranteed that the
+ * rotations set by the caller will be the exact rotations expressed by the client (This is due to settings like
+ * {@link Settings#randomLooking}). If the rotations produced by this behavior are required, then the
+ * {@link #getAimProcessor() aim processor} should be used.
*
- * @param rotation The target rotations
- * @param force Whether or not to "force" the rotations
+ * @param rotation The target rotations
+ * @param blockInteract Whether the target rotations are needed for a block interaction
*/
- void updateTarget(Rotation rotation, boolean force);
+ void updateTarget(Rotation rotation, boolean blockInteract);
+
+ /**
+ * The aim processor instance for this {@link ILookBehavior}, which is responsible for applying additional,
+ * deterministic transformations to the target rotation set by {@link #updateTarget}.
+ *
+ * @return The aim processor
+ * @see IAimProcessor#fork
+ */
+ IAimProcessor getAimProcessor();
}
diff --git a/src/api/java/baritone/api/behavior/look/IAimProcessor.java b/src/api/java/baritone/api/behavior/look/IAimProcessor.java
new file mode 100644
index 000000000..c7c60f413
--- /dev/null
+++ b/src/api/java/baritone/api/behavior/look/IAimProcessor.java
@@ -0,0 +1,45 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.api.behavior.look;
+
+import baritone.api.utils.Rotation;
+
+/**
+ * @author Brady
+ */
+public interface IAimProcessor {
+
+ /**
+ * Returns the actual rotation that will be used when the desired rotation is requested. The returned rotation
+ * always reflects what would happen in the upcoming tick. In other words, it is a pure function, and no internal
+ * state changes. If simulation of the rotation states beyond the next tick is required, then a
+ * {@link IAimProcessor#fork fork} should be created.
+ *
+ * @param desired The desired rotation to set
+ * @return The actual rotation
+ */
+ Rotation peekRotation(Rotation desired);
+
+ /**
+ * Returns a copy of this {@link IAimProcessor} which has its own internal state and is manually tickable.
+ *
+ * @return The forked processor
+ * @see ITickableAimProcessor
+ */
+ ITickableAimProcessor fork();
+}
diff --git a/src/api/java/baritone/api/behavior/look/ITickableAimProcessor.java b/src/api/java/baritone/api/behavior/look/ITickableAimProcessor.java
new file mode 100644
index 000000000..e0a07ae57
--- /dev/null
+++ b/src/api/java/baritone/api/behavior/look/ITickableAimProcessor.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 Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.api.behavior.look;
+
+import baritone.api.utils.Rotation;
+
+/**
+ * @author Brady
+ */
+public interface ITickableAimProcessor extends IAimProcessor {
+
+ /**
+ * Advances the internal state of this aim processor by a single tick.
+ */
+ void tick();
+
+ /**
+ * Calls {@link #tick()} the specified number of times.
+ *
+ * @param ticks The number of calls
+ */
+ void advance(int ticks);
+
+ /**
+ * Returns the actual rotation as provided by {@link #peekRotation(Rotation)}, and then automatically advances the
+ * internal state by one {@link #tick() tick}.
+ *
+ * @param rotation The desired rotation to set
+ * @return The actual rotation
+ */
+ Rotation nextRotation(Rotation rotation);
+}
diff --git a/src/api/java/baritone/api/cache/IWorldProvider.java b/src/api/java/baritone/api/cache/IWorldProvider.java
index 0e54ef469..b9ca149c7 100644
--- a/src/api/java/baritone/api/cache/IWorldProvider.java
+++ b/src/api/java/baritone/api/cache/IWorldProvider.java
@@ -17,6 +17,8 @@
package baritone.api.cache;
+import java.util.function.Consumer;
+
/**
* @author Brady
* @since 9/24/2018
@@ -29,4 +31,11 @@ public interface IWorldProvider {
* @return The current world data
*/
IWorldData getCurrentWorld();
+
+ default void ifWorldLoaded(Consumer callback) {
+ final IWorldData currentWorld = this.getCurrentWorld();
+ if (currentWorld != null) {
+ callback.accept(currentWorld);
+ }
+ }
}
diff --git a/src/api/java/baritone/api/command/datatypes/BlockById.java b/src/api/java/baritone/api/command/datatypes/BlockById.java
index 21562e188..f92c968a2 100644
--- a/src/api/java/baritone/api/command/datatypes/BlockById.java
+++ b/src/api/java/baritone/api/command/datatypes/BlockById.java
@@ -23,11 +23,17 @@ import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.world.level.block.Block;
+import java.util.regex.Pattern;
import java.util.stream.Stream;
public enum BlockById implements IDatatypeFor {
INSTANCE;
+ /**
+ * Matches (domain:)?name? where domain and name are [a-z0-9_.-]+ and [a-z0-9/_.-]+ respectively.
+ */
+ private static Pattern PATTERN = Pattern.compile("(?:[a-z0-9_.-]+:)?[a-z0-9/_.-]*");
+
@Override
public Block get(IDatatypeContext ctx) throws CommandException {
ResourceLocation id = new ResourceLocation(ctx.getConsumer().getString());
@@ -40,13 +46,19 @@ public enum BlockById implements IDatatypeFor {
@Override
public Stream tabComplete(IDatatypeContext ctx) throws CommandException {
+ String arg = ctx.getConsumer().getString();
+
+ if (!PATTERN.matcher(arg).matches()) {
+ return Stream.empty();
+ }
+
return new TabCompleteHelper()
.append(
BuiltInRegistries.BLOCK.keySet()
.stream()
.map(Object::toString)
)
- .filterPrefixNamespaced(ctx.getConsumer().getString())
+ .filterPrefixNamespaced(arg)
.sortAlphabetically()
.stream();
}
diff --git a/src/api/java/baritone/api/command/datatypes/ForAxis.java b/src/api/java/baritone/api/command/datatypes/ForAxis.java
new file mode 100644
index 000000000..369697dcb
--- /dev/null
+++ b/src/api/java/baritone/api/command/datatypes/ForAxis.java
@@ -0,0 +1,43 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.api.command.datatypes;
+
+import baritone.api.command.exception.CommandException;
+import baritone.api.command.helpers.TabCompleteHelper;
+import net.minecraft.core.Direction;
+
+import java.util.Locale;
+import java.util.stream.Stream;
+
+public enum ForAxis implements IDatatypeFor {
+ INSTANCE;
+
+ @Override
+ public Direction.Axis get(IDatatypeContext ctx) throws CommandException {
+ return Direction.Axis.valueOf(ctx.getConsumer().getString().toUpperCase(Locale.US));
+ }
+
+ @Override
+ public Stream tabComplete(IDatatypeContext ctx) throws CommandException {
+ return new TabCompleteHelper()
+ .append(Stream.of(Direction.Axis.values())
+ .map(Direction.Axis::getName).map(String::toLowerCase))
+ .filterPrefix(ctx.getConsumer().getString())
+ .stream();
+ }
+}
diff --git a/src/api/java/baritone/api/command/datatypes/ForBlockOptionalMeta.java b/src/api/java/baritone/api/command/datatypes/ForBlockOptionalMeta.java
index 978450a23..5b949cd63 100644
--- a/src/api/java/baritone/api/command/datatypes/ForBlockOptionalMeta.java
+++ b/src/api/java/baritone/api/command/datatypes/ForBlockOptionalMeta.java
@@ -18,20 +18,137 @@
package baritone.api.command.datatypes;
import baritone.api.command.exception.CommandException;
+import baritone.api.command.helpers.TabCompleteHelper;
import baritone.api.utils.BlockOptionalMeta;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.properties.Property;
+import java.util.Set;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
import java.util.stream.Stream;
public enum ForBlockOptionalMeta implements IDatatypeFor {
INSTANCE;
+ /**
+ * Matches (domain:)?name([(property=value)*])? but the input can be truncated at any position.
+ * domain and name are [a-z0-9_.-]+ and [a-z0-9/_.-]+ because that's what mc 1.13+ accepts.
+ * property and value use the same format as domain.
+ */
+ // Good luck reading this.
+ private static Pattern PATTERN = Pattern.compile("(?:[a-z0-9_.-]+:)?(?:[a-z0-9/_.-]+(?:\\[(?:(?:[a-z0-9_.-]+=[a-z0-9_.-]+,)*(?:[a-z0-9_.-]+(?:=(?:[a-z0-9_.-]+(?:\\])?)?)?)?|\\])?)?)?");
+
@Override
public BlockOptionalMeta get(IDatatypeContext ctx) throws CommandException {
return new BlockOptionalMeta(ctx.getConsumer().getString());
}
@Override
- public Stream tabComplete(IDatatypeContext ctx) {
- return ctx.getConsumer().tabCompleteDatatype(BlockById.INSTANCE);
+ public Stream tabComplete(IDatatypeContext ctx) throws CommandException {
+ String arg = ctx.getConsumer().peekString();
+
+ if (!PATTERN.matcher(arg).matches()) {
+ // Invalid format; we can't complete this.
+ ctx.getConsumer().getString();
+ return Stream.empty();
+ }
+
+ if (arg.endsWith("]")) {
+ // We are already done.
+ ctx.getConsumer().getString();
+ return Stream.empty();
+ }
+
+ if (!arg.contains("[")) {
+ // no properties so we are completing the block id
+ return ctx.getConsumer().tabCompleteDatatype(BlockById.INSTANCE);
+ }
+
+ ctx.getConsumer().getString();
+
+ // destructuring assignment? Please?
+ String blockId, properties;
+ {
+ String[] parts = splitLast(arg, '[');
+ blockId = parts[0];
+ properties = parts[1];
+ }
+
+ Block block = BuiltInRegistries.BLOCK.getOptional(new ResourceLocation(blockId)).orElse(null);
+ if (block == null) {
+ // This block doesn't exist so there's no properties to complete.
+ return Stream.empty();
+ }
+
+ String leadingProperties, lastProperty;
+ {
+ String[] parts = splitLast(properties, ',');
+ leadingProperties = parts[0];
+ lastProperty = parts[1];
+ }
+
+ if (!lastProperty.contains("=")) {
+ // The last property-value pair doesn't have a value yet so we are completing its name
+ Set usedProps = Stream.of(leadingProperties.split(","))
+ .map(pair -> pair.split("=")[0])
+ .collect(Collectors.toSet());
+
+ String prefix = arg.substring(0, arg.length() - lastProperty.length());
+ return new TabCompleteHelper()
+ .append(
+ block.getStateDefinition()
+ .getProperties()
+ .stream()
+ .map(Property::getName)
+ )
+ .filter(prop -> !usedProps.contains(prop))
+ .filterPrefix(lastProperty)
+ .sortAlphabetically()
+ .map(prop -> prefix + prop)
+ .stream();
+ }
+
+ String lastName, lastValue;
+ {
+ String[] parts = splitLast(lastProperty, '=');
+ lastName = parts[0];
+ lastValue = parts[1];
+ }
+
+ // We are completing the value of a property
+ String prefix = arg.substring(0, arg.length() - lastValue.length());
+
+ Property property = block.getStateDefinition().getProperty(lastName);
+ if (property == null) {
+ // The property does not exist so there's no values to complete
+ return Stream.empty();
+ }
+
+ return new TabCompleteHelper()
+ .append(getValues(property))
+ .filterPrefix(lastValue)
+ .sortAlphabetically()
+ .map(val -> prefix + val)
+ .stream();
+ }
+
+ /**
+ * Always returns exactly two strings.
+ * If the separator is not found the FIRST returned string is empty.
+ */
+ private static String[] splitLast(String string, char chr) {
+ int idx = string.lastIndexOf(chr);
+ if (idx == -1) {
+ return new String[]{"", string};
+ }
+ return new String[]{string.substring(0, idx), string.substring(idx + 1)};
+ }
+
+ // this shouldn't need to be a separate method?
+ private static > Stream getValues(Property property) {
+ return property.getPossibleValues().stream().map(property::getName);
}
}
diff --git a/src/api/java/baritone/api/command/datatypes/RelativeFile.java b/src/api/java/baritone/api/command/datatypes/RelativeFile.java
index 7d7e6899b..e85f12971 100644
--- a/src/api/java/baritone/api/command/datatypes/RelativeFile.java
+++ b/src/api/java/baritone/api/command/datatypes/RelativeFile.java
@@ -19,6 +19,8 @@ package baritone.api.command.datatypes;
import baritone.api.command.argument.IArgConsumer;
import baritone.api.command.exception.CommandException;
+import baritone.api.utils.Helper;
+import net.minecraft.client.Minecraft;
import java.io.File;
import java.io.IOException;
@@ -30,8 +32,6 @@ import java.util.Locale;
import java.util.Objects;
import java.util.stream.Stream;
-import static baritone.api.utils.Helper.HELPER;
-
public enum RelativeFile implements IDatatypePost {
INSTANCE;
@@ -93,8 +93,13 @@ public enum RelativeFile implements IDatatypePost {
.filter(s -> !s.contains(" "));
}
+ @Deprecated
public static File gameDir() {
- File gameDir = HELPER.mc.gameDirectory.getAbsoluteFile();
+ return gameDir(Helper.mc);
+ }
+
+ public static File gameDir(Minecraft mc) {
+ File gameDir = mc.gameDirectory.getAbsoluteFile();
if (gameDir.getName().equals(".")) {
return gameDir.getParentFile();
}
diff --git a/src/api/java/baritone/api/command/exception/CommandUnhandledException.java b/src/api/java/baritone/api/command/exception/CommandUnhandledException.java
index d615ff2cd..a1f826262 100644
--- a/src/api/java/baritone/api/command/exception/CommandUnhandledException.java
+++ b/src/api/java/baritone/api/command/exception/CommandUnhandledException.java
@@ -19,8 +19,8 @@ package baritone.api.command.exception;
import baritone.api.command.ICommand;
import baritone.api.command.argument.ICommandArgument;
+
import java.util.List;
-import net.minecraft.ChatFormatting;
import static baritone.api.utils.Helper.HELPER;
@@ -36,10 +36,6 @@ public class CommandUnhandledException extends RuntimeException implements IComm
@Override
public void handle(ICommand command, List args) {
- HELPER.logDirect("An unhandled exception occurred. " +
- "The error is in your game's log, please report this at https://github.com/cabaletta/baritone/issues",
- ChatFormatting.RED);
-
- this.printStackTrace();
+ HELPER.logUnhandledException(this);
}
}
diff --git a/src/api/java/baritone/api/command/helpers/TabCompleteHelper.java b/src/api/java/baritone/api/command/helpers/TabCompleteHelper.java
index a7dfb7f8a..4f822352a 100644
--- a/src/api/java/baritone/api/command/helpers/TabCompleteHelper.java
+++ b/src/api/java/baritone/api/command/helpers/TabCompleteHelper.java
@@ -252,7 +252,7 @@ public class TabCompleteHelper {
public TabCompleteHelper addSettings() {
return append(
BaritoneAPI.getSettings().allSettings.stream()
- .filter(s -> !SettingsUtil.javaOnlySetting(s))
+ .filter(s -> !s.isJavaOnly())
.map(Settings.Setting::getName)
.sorted(String.CASE_INSENSITIVE_ORDER)
);
diff --git a/src/api/java/baritone/api/event/events/BlockChangeEvent.java b/src/api/java/baritone/api/event/events/BlockChangeEvent.java
new file mode 100644
index 000000000..4fc496eb5
--- /dev/null
+++ b/src/api/java/baritone/api/event/events/BlockChangeEvent.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 Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.api.event.events;
+
+import baritone.api.utils.Pair;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.block.state.BlockState;
+
+import java.util.List;
+
+/**
+ * @author Brady
+ */
+public final class BlockChangeEvent {
+
+ private final ChunkPos chunk;
+ private final List> blocks;
+
+ public BlockChangeEvent(ChunkPos pos, List> blocks) {
+ this.chunk = pos;
+ this.blocks = blocks;
+ }
+
+ public ChunkPos getChunkPos() {
+ return this.chunk;
+ }
+
+ public List> getBlocks() {
+ return this.blocks;
+ }
+}
diff --git a/src/api/java/baritone/api/event/events/ChunkEvent.java b/src/api/java/baritone/api/event/events/ChunkEvent.java
index f27475bce..bb22a47b1 100644
--- a/src/api/java/baritone/api/event/events/ChunkEvent.java
+++ b/src/api/java/baritone/api/event/events/ChunkEvent.java
@@ -57,31 +57,38 @@ public final class ChunkEvent {
/**
* @return The state of the event
*/
- public final EventState getState() {
+ public EventState getState() {
return this.state;
}
/**
* @return The type of chunk event that occurred;
*/
- public final Type getType() {
+ public Type getType() {
return this.type;
}
/**
* @return The Chunk X position.
*/
- public final int getX() {
+ public int getX() {
return this.x;
}
/**
* @return The Chunk Z position.
*/
- public final int getZ() {
+ public int getZ() {
return this.z;
}
+ /**
+ * @return {@code true} if the event was fired after a chunk population
+ */
+ public boolean isPostPopulate() {
+ return this.state == EventState.POST && this.type.isPopulate();
+ }
+
public enum Type {
/**
@@ -106,6 +113,10 @@ public final class ChunkEvent {
*
* And it's a partial chunk
*/
- POPULATE_PARTIAL
+ POPULATE_PARTIAL;
+
+ public final boolean isPopulate() {
+ return this == POPULATE_FULL || this == POPULATE_PARTIAL;
+ }
}
}
diff --git a/src/api/java/baritone/api/event/events/RotationMoveEvent.java b/src/api/java/baritone/api/event/events/RotationMoveEvent.java
index bae83c0fa..c5a9ea9f9 100644
--- a/src/api/java/baritone/api/event/events/RotationMoveEvent.java
+++ b/src/api/java/baritone/api/event/events/RotationMoveEvent.java
@@ -17,6 +17,7 @@
package baritone.api.event.events;
+import baritone.api.utils.Rotation;
import net.minecraft.world.entity.Entity;
import net.minecraft.world.entity.LivingEntity;
import net.minecraft.world.phys.Vec3;
@@ -32,14 +33,27 @@ public final class RotationMoveEvent {
*/
private final Type type;
+ private final Rotation original;
+
/**
* The yaw rotation
*/
private float yaw;
- public RotationMoveEvent(Type type, float yaw) {
+ /**
+ * The pitch rotation
+ */
+ private float pitch;
+
+ public RotationMoveEvent(Type type, float yaw, float pitch) {
this.type = type;
+ this.original = new Rotation(yaw, pitch);
this.yaw = yaw;
+ this.pitch = pitch;
+ }
+
+ public Rotation getOriginal() {
+ return this.original;
}
/**
@@ -47,21 +61,37 @@ public final class RotationMoveEvent {
*
* @param yaw Yaw rotation
*/
- public final void setYaw(float yaw) {
+ public void setYaw(float yaw) {
this.yaw = yaw;
}
/**
* @return The yaw rotation
*/
- public final float getYaw() {
+ public float getYaw() {
return this.yaw;
}
+ /**
+ * Set the pitch movement rotation
+ *
+ * @param pitch Pitch rotation
+ */
+ public void setPitch(float pitch) {
+ this.pitch = pitch;
+ }
+
+ /**
+ * @return The pitch rotation
+ */
+ public float getPitch() {
+ return pitch;
+ }
+
/**
* @return The type of the event
*/
- public final Type getType() {
+ public Type getType() {
return this.type;
}
diff --git a/src/api/java/baritone/api/event/events/TickEvent.java b/src/api/java/baritone/api/event/events/TickEvent.java
index 5c484ae49..405ad3c49 100644
--- a/src/api/java/baritone/api/event/events/TickEvent.java
+++ b/src/api/java/baritone/api/event/events/TickEvent.java
@@ -18,9 +18,18 @@
package baritone.api.event.events;
import baritone.api.event.events.type.EventState;
+import net.minecraft.client.Minecraft;
import java.util.function.BiFunction;
+/**
+ * Called on and after each game tick of the primary {@link Minecraft} instance and dispatched to all Baritone
+ * instances.
+ *
+ * When {@link #state} is {@link EventState#PRE}, the event is being called just prior to when the current in-game
+ * screen is ticked. When {@link #state} is {@link EventState#POST}, the event is being called at the very end
+ * of the {@link Minecraft#runTick()} method.
+ */
public final class TickEvent {
private static int overallTickCount;
diff --git a/src/api/java/baritone/api/event/listener/AbstractGameEventListener.java b/src/api/java/baritone/api/event/listener/AbstractGameEventListener.java
index 9eac8de46..54aabe387 100644
--- a/src/api/java/baritone/api/event/listener/AbstractGameEventListener.java
+++ b/src/api/java/baritone/api/event/listener/AbstractGameEventListener.java
@@ -33,6 +33,9 @@ public interface AbstractGameEventListener extends IGameEventListener {
@Override
default void onTick(TickEvent event) {}
+ @Override
+ default void onPostTick(TickEvent event) {}
+
@Override
default void onPlayerUpdate(PlayerUpdateEvent event) {}
@@ -45,6 +48,9 @@ public interface AbstractGameEventListener extends IGameEventListener {
@Override
default void onChunkEvent(ChunkEvent event) {}
+ @Override
+ default void onBlockChange(BlockChangeEvent event) {}
+
@Override
default void onRenderPass(RenderEvent event) {}
diff --git a/src/api/java/baritone/api/event/listener/IGameEventListener.java b/src/api/java/baritone/api/event/listener/IGameEventListener.java
index a34ea4ef3..6939f8d66 100644
--- a/src/api/java/baritone/api/event/listener/IGameEventListener.java
+++ b/src/api/java/baritone/api/event/listener/IGameEventListener.java
@@ -40,6 +40,14 @@ public interface IGameEventListener {
*/
void onTick(TickEvent event);
+ /**
+ * Run once per game tick after the tick is completed
+ *
+ * @param event The event
+ * @see Minecraft#runTick()
+ */
+ void onPostTick(TickEvent event);
+
/**
* Run once per game tick from before and after the player rotation is sent to the server.
*
@@ -70,6 +78,13 @@ public interface IGameEventListener {
*/
void onChunkEvent(ChunkEvent event);
+ /**
+ * Runs after a single or multi block change packet is received and processed.
+ *
+ * @param event The event
+ */
+ void onBlockChange(BlockChangeEvent event);
+
/**
* Runs once per world render pass.
*
diff --git a/src/api/java/baritone/api/pathing/goals/GoalAxis.java b/src/api/java/baritone/api/pathing/goals/GoalAxis.java
index 7c9b26705..6e2f84e7a 100644
--- a/src/api/java/baritone/api/pathing/goals/GoalAxis.java
+++ b/src/api/java/baritone/api/pathing/goals/GoalAxis.java
@@ -42,6 +42,16 @@ public class GoalAxis implements Goal {
return flatAxisDistance * BaritoneAPI.getSettings().costHeuristic.value + GoalYLevel.calculate(BaritoneAPI.getSettings().axisHeight.value, y);
}
+ @Override
+ public boolean equals(Object o) {
+ return o.getClass() == GoalAxis.class;
+ }
+
+ @Override
+ public int hashCode() {
+ return 201385781;
+ }
+
@Override
public String toString() {
return "GoalAxis";
diff --git a/src/api/java/baritone/api/pathing/goals/GoalBlock.java b/src/api/java/baritone/api/pathing/goals/GoalBlock.java
index 7cb9da14a..4bebe07a3 100644
--- a/src/api/java/baritone/api/pathing/goals/GoalBlock.java
+++ b/src/api/java/baritone/api/pathing/goals/GoalBlock.java
@@ -17,6 +17,7 @@
package baritone.api.pathing.goals;
+import baritone.api.utils.BetterBlockPos;
import baritone.api.utils.SettingsUtil;
import baritone.api.utils.interfaces.IGoalRenderPos;
import net.minecraft.core.BlockPos;
@@ -66,6 +67,26 @@ public class GoalBlock implements Goal, IGoalRenderPos {
return calculate(xDiff, yDiff, zDiff);
}
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+
+ GoalBlock goal = (GoalBlock) o;
+ return x == goal.x
+ && y == goal.y
+ && z == goal.z;
+ }
+
+ @Override
+ public int hashCode() {
+ return (int) BetterBlockPos.longHash(x, y, z) * 905165533;
+ }
+
@Override
public String toString() {
return String.format(
diff --git a/src/api/java/baritone/api/pathing/goals/GoalComposite.java b/src/api/java/baritone/api/pathing/goals/GoalComposite.java
index 47522492b..8e13a86e4 100644
--- a/src/api/java/baritone/api/pathing/goals/GoalComposite.java
+++ b/src/api/java/baritone/api/pathing/goals/GoalComposite.java
@@ -67,6 +67,24 @@ public class GoalComposite implements Goal {
return min;
}
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+
+ GoalComposite goal = (GoalComposite) o;
+ return Arrays.equals(goals, goal.goals);
+ }
+
+ @Override
+ public int hashCode() {
+ return Arrays.hashCode(goals);
+ }
+
@Override
public String toString() {
return "GoalComposite" + Arrays.toString(goals);
diff --git a/src/api/java/baritone/api/pathing/goals/GoalGetToBlock.java b/src/api/java/baritone/api/pathing/goals/GoalGetToBlock.java
index 8d15e4bc9..1c04f7c6d 100644
--- a/src/api/java/baritone/api/pathing/goals/GoalGetToBlock.java
+++ b/src/api/java/baritone/api/pathing/goals/GoalGetToBlock.java
@@ -17,6 +17,7 @@
package baritone.api.pathing.goals;
+import baritone.api.utils.BetterBlockPos;
import baritone.api.utils.SettingsUtil;
import baritone.api.utils.interfaces.IGoalRenderPos;
import net.minecraft.core.BlockPos;
@@ -60,6 +61,26 @@ public class GoalGetToBlock implements Goal, IGoalRenderPos {
return GoalBlock.calculate(xDiff, yDiff < 0 ? yDiff + 1 : yDiff, zDiff);
}
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+
+ GoalGetToBlock goal = (GoalGetToBlock) o;
+ return x == goal.x
+ && y == goal.y
+ && z == goal.z;
+ }
+
+ @Override
+ public int hashCode() {
+ return (int) BetterBlockPos.longHash(x, y, z) * -49639096;
+ }
+
@Override
public String toString() {
return String.format(
diff --git a/src/api/java/baritone/api/pathing/goals/GoalInverted.java b/src/api/java/baritone/api/pathing/goals/GoalInverted.java
index 354e2ce39..4a3f75315 100644
--- a/src/api/java/baritone/api/pathing/goals/GoalInverted.java
+++ b/src/api/java/baritone/api/pathing/goals/GoalInverted.java
@@ -17,6 +17,8 @@
package baritone.api.pathing.goals;
+import java.util.Objects;
+
/**
* Invert any goal.
*
@@ -50,6 +52,24 @@ public class GoalInverted implements Goal {
return Double.NEGATIVE_INFINITY;
}
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+
+ GoalInverted goal = (GoalInverted) o;
+ return Objects.equals(origin, goal.origin);
+ }
+
+ @Override
+ public int hashCode() {
+ return origin.hashCode() * 495796690;
+ }
+
@Override
public String toString() {
return String.format("GoalInverted{%s}", origin.toString());
diff --git a/src/api/java/baritone/api/pathing/goals/GoalNear.java b/src/api/java/baritone/api/pathing/goals/GoalNear.java
index 6ee35ad7b..351c08021 100644
--- a/src/api/java/baritone/api/pathing/goals/GoalNear.java
+++ b/src/api/java/baritone/api/pathing/goals/GoalNear.java
@@ -17,6 +17,7 @@
package baritone.api.pathing.goals;
+import baritone.api.utils.BetterBlockPos;
import baritone.api.utils.SettingsUtil;
import baritone.api.utils.interfaces.IGoalRenderPos;
import it.unimi.dsi.fastutil.doubles.DoubleIterator;
@@ -86,6 +87,27 @@ public class GoalNear implements Goal, IGoalRenderPos {
return new BlockPos(x, y, z);
}
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+
+ GoalNear goal = (GoalNear) o;
+ return x == goal.x
+ && y == goal.y
+ && z == goal.z
+ && rangeSq == goal.rangeSq;
+ }
+
+ @Override
+ public int hashCode() {
+ return (int) BetterBlockPos.longHash(x, y, z) + rangeSq;
+ }
+
@Override
public String toString() {
return String.format(
diff --git a/src/api/java/baritone/api/pathing/goals/GoalRunAway.java b/src/api/java/baritone/api/pathing/goals/GoalRunAway.java
index 3906713f2..49b6f708d 100644
--- a/src/api/java/baritone/api/pathing/goals/GoalRunAway.java
+++ b/src/api/java/baritone/api/pathing/goals/GoalRunAway.java
@@ -23,6 +23,7 @@ import it.unimi.dsi.fastutil.doubles.DoubleOpenHashSet;
import net.minecraft.core.BlockPos;
import java.util.Arrays;
+import java.util.Objects;
/**
* Useful for automated combat (retreating specifically)
@@ -124,6 +125,29 @@ public class GoalRunAway implements Goal {
return maxInside;
}
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+
+ GoalRunAway goal = (GoalRunAway) o;
+ return distanceSq == goal.distanceSq
+ && Arrays.equals(from, goal.from)
+ && Objects.equals(maintainY, goal.maintainY);
+ }
+
+ @Override
+ public int hashCode() {
+ int hash = Arrays.hashCode(from);
+ hash = hash * 1196803141 + distanceSq;
+ hash = hash * -2053788840 + maintainY;
+ return hash;
+ }
+
@Override
public String toString() {
if (maintainY != null) {
diff --git a/src/api/java/baritone/api/pathing/goals/GoalStrictDirection.java b/src/api/java/baritone/api/pathing/goals/GoalStrictDirection.java
index c4a8a6272..6facfbd79 100644
--- a/src/api/java/baritone/api/pathing/goals/GoalStrictDirection.java
+++ b/src/api/java/baritone/api/pathing/goals/GoalStrictDirection.java
@@ -17,6 +17,7 @@
package baritone.api.pathing.goals;
+import baritone.api.utils.BetterBlockPos;
import baritone.api.utils.SettingsUtil;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
@@ -69,6 +70,31 @@ public class GoalStrictDirection implements Goal {
return Double.NEGATIVE_INFINITY;
}
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+
+ GoalStrictDirection goal = (GoalStrictDirection) o;
+ return x == goal.x
+ && y == goal.y
+ && z == goal.z
+ && dx == goal.dx
+ && dz == goal.dz;
+ }
+
+ @Override
+ public int hashCode() {
+ int hash = (int) BetterBlockPos.longHash(x, y, z);
+ hash = hash * 630627507 + dx;
+ hash = hash * -283028380 + dz;
+ return hash;
+ }
+
@Override
public String toString() {
return String.format(
diff --git a/src/api/java/baritone/api/pathing/goals/GoalTwoBlocks.java b/src/api/java/baritone/api/pathing/goals/GoalTwoBlocks.java
index 1b7213471..c9325e3ad 100644
--- a/src/api/java/baritone/api/pathing/goals/GoalTwoBlocks.java
+++ b/src/api/java/baritone/api/pathing/goals/GoalTwoBlocks.java
@@ -17,6 +17,7 @@
package baritone.api.pathing.goals;
+import baritone.api.utils.BetterBlockPos;
import baritone.api.utils.SettingsUtil;
import baritone.api.utils.interfaces.IGoalRenderPos;
import net.minecraft.core.BlockPos;
@@ -72,6 +73,26 @@ public class GoalTwoBlocks implements Goal, IGoalRenderPos {
return new BlockPos(x, y, z);
}
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+
+ GoalTwoBlocks goal = (GoalTwoBlocks) o;
+ return x == goal.x
+ && y == goal.y
+ && z == goal.z;
+ }
+
+ @Override
+ public int hashCode() {
+ return (int) BetterBlockPos.longHash(x, y, z) * 516508351;
+ }
+
@Override
public String toString() {
return String.format(
diff --git a/src/api/java/baritone/api/pathing/goals/GoalXZ.java b/src/api/java/baritone/api/pathing/goals/GoalXZ.java
index f70f6c4f7..b72711283 100644
--- a/src/api/java/baritone/api/pathing/goals/GoalXZ.java
+++ b/src/api/java/baritone/api/pathing/goals/GoalXZ.java
@@ -64,6 +64,27 @@ public class GoalXZ implements Goal {
return calculate(xDiff, zDiff);
}
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+
+ GoalXZ goal = (GoalXZ) o;
+ return x == goal.x && z == goal.z;
+ }
+
+ @Override
+ public int hashCode() {
+ int hash = 1791873246;
+ hash = hash * 222601791 + x;
+ hash = hash * -1331679453 + z;
+ return hash;
+ }
+
@Override
public String toString() {
return String.format(
diff --git a/src/api/java/baritone/api/pathing/goals/GoalYLevel.java b/src/api/java/baritone/api/pathing/goals/GoalYLevel.java
index 603ef9bd1..442906ad1 100644
--- a/src/api/java/baritone/api/pathing/goals/GoalYLevel.java
+++ b/src/api/java/baritone/api/pathing/goals/GoalYLevel.java
@@ -58,6 +58,24 @@ public class GoalYLevel implements Goal, ActionCosts {
return 0;
}
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+
+ GoalYLevel goal = (GoalYLevel) o;
+ return level == goal.level;
+ }
+
+ @Override
+ public int hashCode() {
+ return level * 1271009915;
+ }
+
@Override
public String toString() {
return String.format(
diff --git a/src/api/java/baritone/api/process/IBuilderProcess.java b/src/api/java/baritone/api/process/IBuilderProcess.java
index 9f0ab1032..77250ce73 100644
--- a/src/api/java/baritone/api/process/IBuilderProcess.java
+++ b/src/api/java/baritone/api/process/IBuilderProcess.java
@@ -50,6 +50,7 @@ public interface IBuilderProcess extends IBaritoneProcess {
*/
boolean build(String name, File schematic, Vec3i origin);
+ @Deprecated
default boolean build(String schematicFile, BlockPos origin) {
File file = new File(new File(Minecraft.getInstance().gameDirectory, "schematics"), schematicFile);
return build(schematicFile, file, origin);
diff --git a/src/api/java/baritone/api/process/ICustomGoalProcess.java b/src/api/java/baritone/api/process/ICustomGoalProcess.java
index 5084aff2f..2bae55ce3 100644
--- a/src/api/java/baritone/api/process/ICustomGoalProcess.java
+++ b/src/api/java/baritone/api/process/ICustomGoalProcess.java
@@ -38,6 +38,11 @@ public interface ICustomGoalProcess extends IBaritoneProcess {
*/
Goal getGoal();
+ /**
+ * @return The most recent set goal, which doesn't invalidate upon {@link #onLostControl()}
+ */
+ Goal mostRecentGoal();
+
/**
* Sets the goal and begins the path execution.
*
diff --git a/src/api/java/baritone/api/process/IElytraProcess.java b/src/api/java/baritone/api/process/IElytraProcess.java
new file mode 100644
index 000000000..28328f901
--- /dev/null
+++ b/src/api/java/baritone/api/process/IElytraProcess.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 Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.api.process;
+
+import baritone.api.pathing.goals.Goal;
+import net.minecraft.core.BlockPos;
+
+public interface IElytraProcess extends IBaritoneProcess {
+
+ void repackChunks();
+
+ /**
+ * @return Where it is currently flying to, null if not active
+ */
+ BlockPos currentDestination();
+
+ void pathTo(BlockPos destination);
+
+ void pathTo(Goal destination);
+
+ /**
+ * Resets the state of the process but will maintain the same destination and will try to keep flying
+ */
+ void resetState();
+
+ /**
+ * @return {@code true} if the native library loaded and elytra is actually usable
+ */
+ boolean isLoaded();
+
+ /*
+ * FOR INTERNAL USE ONLY. MAY BE REMOVED AT ANY TIME.
+ */
+ boolean isSafeToCancel();
+}
diff --git a/src/api/java/baritone/api/process/PathingCommandType.java b/src/api/java/baritone/api/process/PathingCommandType.java
index af25591af..cde38eaf2 100644
--- a/src/api/java/baritone/api/process/PathingCommandType.java
+++ b/src/api/java/baritone/api/process/PathingCommandType.java
@@ -56,5 +56,10 @@ public enum PathingCommandType {
/**
* Go and ask the next process what to do
*/
- DEFER
+ DEFER,
+
+ /**
+ * Sets the goal and calculates a path, but pauses instead of immediately starting the path.
+ */
+ SET_GOAL_AND_PAUSE
}
diff --git a/src/api/java/baritone/api/schematic/MaskSchematic.java b/src/api/java/baritone/api/schematic/MaskSchematic.java
index ee56f3425..a5749ff57 100644
--- a/src/api/java/baritone/api/schematic/MaskSchematic.java
+++ b/src/api/java/baritone/api/schematic/MaskSchematic.java
@@ -17,9 +17,11 @@
package baritone.api.schematic;
-import java.util.List;
+import baritone.api.schematic.mask.Mask;
import net.minecraft.world.level.block.state.BlockState;
+import java.util.List;
+
public abstract class MaskSchematic extends AbstractSchematic {
private final ISchematic schematic;
@@ -40,4 +42,14 @@ public abstract class MaskSchematic extends AbstractSchematic {
public BlockState desiredState(int x, int y, int z, BlockState current, List approxPlaceable) {
return schematic.desiredState(x, y, z, current, approxPlaceable);
}
+
+ public static MaskSchematic create(ISchematic schematic, Mask function) {
+ return new MaskSchematic(schematic) {
+
+ @Override
+ protected boolean partOfMask(int x, int y, int z, BlockState currentState) {
+ return function.partOfMask(x, y, z, currentState);
+ }
+ };
+ }
}
diff --git a/src/api/java/baritone/api/schematic/mask/AbstractMask.java b/src/api/java/baritone/api/schematic/mask/AbstractMask.java
new file mode 100644
index 000000000..ce92af0ec
--- /dev/null
+++ b/src/api/java/baritone/api/schematic/mask/AbstractMask.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 Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.api.schematic.mask;
+
+/**
+ * @author Brady
+ */
+public abstract class AbstractMask implements Mask {
+
+ private final int widthX;
+ private final int heightY;
+ private final int lengthZ;
+
+ public AbstractMask(int widthX, int heightY, int lengthZ) {
+ this.widthX = widthX;
+ this.heightY = heightY;
+ this.lengthZ = lengthZ;
+ }
+
+ @Override
+ public int widthX() {
+ return this.widthX;
+ }
+
+ @Override
+ public int heightY() {
+ return this.heightY;
+ }
+
+ @Override
+ public int lengthZ() {
+ return this.lengthZ;
+ }
+}
diff --git a/src/api/java/baritone/api/schematic/mask/Mask.java b/src/api/java/baritone/api/schematic/mask/Mask.java
new file mode 100644
index 000000000..c8b1f15a1
--- /dev/null
+++ b/src/api/java/baritone/api/schematic/mask/Mask.java
@@ -0,0 +1,60 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.api.schematic.mask;
+
+import baritone.api.schematic.mask.operator.BinaryOperatorMask;
+import baritone.api.schematic.mask.operator.NotMask;
+import baritone.api.utils.BooleanBinaryOperators;
+import net.minecraft.world.level.block.state.BlockState;
+
+/**
+ * @author Brady
+ */
+public interface Mask {
+
+ /**
+ * @param x The relative x position of the block
+ * @param y The relative y position of the block
+ * @param z The relative z position of the block
+ * @param currentState The current state of that block in the world, may be {@code null}
+ * @return Whether the given position is included in this mask
+ */
+ boolean partOfMask(int x, int y, int z, BlockState currentState);
+
+ int widthX();
+
+ int heightY();
+
+ int lengthZ();
+
+ default Mask not() {
+ return new NotMask(this);
+ }
+
+ default Mask union(Mask other) {
+ return new BinaryOperatorMask(this, other, BooleanBinaryOperators.OR);
+ }
+
+ default Mask intersection(Mask other) {
+ return new BinaryOperatorMask(this, other, BooleanBinaryOperators.AND);
+ }
+
+ default Mask xor(Mask other) {
+ return new BinaryOperatorMask(this, other, BooleanBinaryOperators.XOR);
+ }
+}
diff --git a/src/api/java/baritone/api/schematic/mask/PreComputedMask.java b/src/api/java/baritone/api/schematic/mask/PreComputedMask.java
new file mode 100644
index 000000000..aed26cc94
--- /dev/null
+++ b/src/api/java/baritone/api/schematic/mask/PreComputedMask.java
@@ -0,0 +1,44 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.api.schematic.mask;
+
+/**
+ * @author Brady
+ */
+final class PreComputedMask extends AbstractMask implements StaticMask {
+
+ private final boolean[][][] mask;
+
+ public PreComputedMask(StaticMask mask) {
+ super(mask.widthX(), mask.heightY(), mask.lengthZ());
+
+ this.mask = new boolean[this.heightY()][this.lengthZ()][this.widthX()];
+ for (int y = 0; y < this.heightY(); y++) {
+ for (int z = 0; z < this.lengthZ(); z++) {
+ for (int x = 0; x < this.widthX(); x++) {
+ this.mask[y][z][x] = mask.partOfMask(x, y, z);
+ }
+ }
+ }
+ }
+
+ @Override
+ public boolean partOfMask(int x, int y, int z) {
+ return this.mask[y][z][x];
+ }
+}
diff --git a/src/api/java/baritone/api/schematic/mask/StaticMask.java b/src/api/java/baritone/api/schematic/mask/StaticMask.java
new file mode 100644
index 000000000..9925ffca2
--- /dev/null
+++ b/src/api/java/baritone/api/schematic/mask/StaticMask.java
@@ -0,0 +1,82 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.api.schematic.mask;
+
+import baritone.api.schematic.mask.operator.BinaryOperatorMask;
+import baritone.api.schematic.mask.operator.NotMask;
+import baritone.api.utils.BooleanBinaryOperators;
+import net.minecraft.world.level.block.state.BlockState;
+
+/**
+ * A mask that is context-free. In other words, it doesn't require the current block state to determine if a relative
+ * position is a part of the mask.
+ *
+ * @author Brady
+ */
+public interface StaticMask extends Mask {
+
+ /**
+ * Determines if a given relative coordinate is included in this mask, without the need for the current block state.
+ *
+ * @param x The relative x position of the block
+ * @param y The relative y position of the block
+ * @param z The relative z position of the block
+ * @return Whether the given position is included in this mask
+ */
+ boolean partOfMask(int x, int y, int z);
+
+ /**
+ * Implements the parent {@link Mask#partOfMask partOfMask function} by calling the static function
+ * provided in this functional interface without needing the {@link BlockState} argument. This {@code default}
+ * implementation should NOT be overriden.
+ *
+ * @param x The relative x position of the block
+ * @param y The relative y position of the block
+ * @param z The relative z position of the block
+ * @param currentState The current state of that block in the world, may be {@code null}
+ * @return Whether the given position is included in this mask
+ */
+ @Override
+ default boolean partOfMask(int x, int y, int z, BlockState currentState) {
+ return this.partOfMask(x, y, z);
+ }
+
+ @Override
+ default StaticMask not() {
+ return new NotMask.Static(this);
+ }
+
+ default StaticMask union(StaticMask other) {
+ return new BinaryOperatorMask.Static(this, other, BooleanBinaryOperators.OR);
+ }
+
+ default StaticMask intersection(StaticMask other) {
+ return new BinaryOperatorMask.Static(this, other, BooleanBinaryOperators.AND);
+ }
+
+ default StaticMask xor(StaticMask other) {
+ return new BinaryOperatorMask.Static(this, other, BooleanBinaryOperators.XOR);
+ }
+
+ /**
+ * Returns a pre-computed mask using {@code this} function, with the specified size parameters.
+ */
+ default StaticMask compute() {
+ return new PreComputedMask(this);
+ }
+}
diff --git a/src/api/java/baritone/api/schematic/mask/operator/BinaryOperatorMask.java b/src/api/java/baritone/api/schematic/mask/operator/BinaryOperatorMask.java
new file mode 100644
index 000000000..08975e521
--- /dev/null
+++ b/src/api/java/baritone/api/schematic/mask/operator/BinaryOperatorMask.java
@@ -0,0 +1,79 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.api.schematic.mask.operator;
+
+import baritone.api.schematic.mask.AbstractMask;
+import baritone.api.schematic.mask.Mask;
+import baritone.api.schematic.mask.StaticMask;
+import baritone.api.utils.BooleanBinaryOperator;
+import net.minecraft.world.level.block.state.BlockState;
+
+/**
+ * @author Brady
+ */
+public final class BinaryOperatorMask extends AbstractMask {
+
+ private final Mask a;
+ private final Mask b;
+ private final BooleanBinaryOperator operator;
+
+ public BinaryOperatorMask(Mask a, Mask b, BooleanBinaryOperator operator) {
+ super(Math.max(a.widthX(), b.widthX()), Math.max(a.heightY(), b.heightY()), Math.max(a.lengthZ(), b.lengthZ()));
+ this.a = a;
+ this.b = b;
+ this.operator = operator;
+ }
+
+ @Override
+ public boolean partOfMask(int x, int y, int z, BlockState currentState) {
+ return this.operator.applyAsBoolean(
+ partOfMask(a, x, y, z, currentState),
+ partOfMask(b, x, y, z, currentState)
+ );
+ }
+
+ private static boolean partOfMask(Mask mask, int x, int y, int z, BlockState currentState) {
+ return x < mask.widthX() && y < mask.heightY() && z < mask.lengthZ() && mask.partOfMask(x, y, z, currentState);
+ }
+
+ public static final class Static extends AbstractMask implements StaticMask {
+
+ private final StaticMask a;
+ private final StaticMask b;
+ private final BooleanBinaryOperator operator;
+
+ public Static(StaticMask a, StaticMask b, BooleanBinaryOperator operator) {
+ super(Math.max(a.widthX(), b.widthX()), Math.max(a.heightY(), b.heightY()), Math.max(a.lengthZ(), b.lengthZ()));
+ this.a = a;
+ this.b = b;
+ this.operator = operator;
+ }
+
+ @Override
+ public boolean partOfMask(int x, int y, int z) {
+ return this.operator.applyAsBoolean(
+ partOfMask(a, x, y, z),
+ partOfMask(b, x, y, z)
+ );
+ }
+
+ private static boolean partOfMask(StaticMask mask, int x, int y, int z) {
+ return x < mask.widthX() && y < mask.heightY() && z < mask.lengthZ() && mask.partOfMask(x, y, z);
+ }
+ }
+}
diff --git a/src/api/java/baritone/api/schematic/mask/operator/NotMask.java b/src/api/java/baritone/api/schematic/mask/operator/NotMask.java
new file mode 100644
index 000000000..9d0dfcd6d
--- /dev/null
+++ b/src/api/java/baritone/api/schematic/mask/operator/NotMask.java
@@ -0,0 +1,56 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.api.schematic.mask.operator;
+
+import baritone.api.schematic.mask.AbstractMask;
+import baritone.api.schematic.mask.Mask;
+import baritone.api.schematic.mask.StaticMask;
+import net.minecraft.world.level.block.state.BlockState;
+
+/**
+ * @author Brady
+ */
+public final class NotMask extends AbstractMask {
+
+ private final Mask source;
+
+ public NotMask(Mask source) {
+ super(source.widthX(), source.heightY(), source.lengthZ());
+ this.source = source;
+ }
+
+ @Override
+ public boolean partOfMask(int x, int y, int z, BlockState currentState) {
+ return !this.source.partOfMask(x, y, z, currentState);
+ }
+
+ public static final class Static extends AbstractMask implements StaticMask {
+
+ private final StaticMask source;
+
+ public Static(StaticMask source) {
+ super(source.widthX(), source.heightY(), source.lengthZ());
+ this.source = source;
+ }
+
+ @Override
+ public boolean partOfMask(int x, int y, int z) {
+ return !this.source.partOfMask(x, y, z);
+ }
+ }
+}
diff --git a/src/api/java/baritone/api/schematic/mask/shape/CylinderMask.java b/src/api/java/baritone/api/schematic/mask/shape/CylinderMask.java
new file mode 100644
index 000000000..093a27e38
--- /dev/null
+++ b/src/api/java/baritone/api/schematic/mask/shape/CylinderMask.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 Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.api.schematic.mask.shape;
+
+import baritone.api.schematic.mask.AbstractMask;
+import baritone.api.schematic.mask.StaticMask;
+import net.minecraft.core.Direction;
+
+/**
+ * @author Brady
+ */
+public final class CylinderMask extends AbstractMask implements StaticMask {
+
+ private final double centerA;
+ private final double centerB;
+ private final double radiusSqA;
+ private final double radiusSqB;
+ private final boolean filled;
+ private final Direction.Axis alignment;
+
+ public CylinderMask(int widthX, int heightY, int lengthZ, boolean filled, Direction.Axis alignment) {
+ super(widthX, heightY, lengthZ);
+ this.centerA = this.getA(widthX, heightY, alignment) / 2.0;
+ this.centerB = this.getB(heightY, lengthZ, alignment) / 2.0;
+ this.radiusSqA = (this.centerA - 1) * (this.centerA - 1);
+ this.radiusSqB = (this.centerB - 1) * (this.centerB - 1);
+ this.filled = filled;
+ this.alignment = alignment;
+ }
+
+ @Override
+ public boolean partOfMask(int x, int y, int z) {
+ double da = Math.abs((this.getA(x, y, this.alignment) + 0.5) - this.centerA);
+ double db = Math.abs((this.getB(y, z, this.alignment) + 0.5) - this.centerB);
+ if (this.outside(da, db)) {
+ return false;
+ }
+ return this.filled
+ || this.outside(da + 1, db)
+ || this.outside(da, db + 1);
+ }
+
+ private boolean outside(double da, double db) {
+ return da * da / this.radiusSqA + db * db / this.radiusSqB > 1;
+ }
+
+ private static int getA(int x, int y, Direction.Axis alignment) {
+ return alignment == Direction.Axis.X ? y : x;
+ }
+
+ private static int getB(int y, int z, Direction.Axis alignment) {
+ return alignment == Direction.Axis.Z ? y : z;
+ }
+}
diff --git a/src/api/java/baritone/api/schematic/mask/shape/SphereMask.java b/src/api/java/baritone/api/schematic/mask/shape/SphereMask.java
new file mode 100644
index 000000000..d805c98a8
--- /dev/null
+++ b/src/api/java/baritone/api/schematic/mask/shape/SphereMask.java
@@ -0,0 +1,64 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.api.schematic.mask.shape;
+
+import baritone.api.schematic.mask.AbstractMask;
+import baritone.api.schematic.mask.StaticMask;
+
+/**
+ * @author Brady
+ */
+public final class SphereMask extends AbstractMask implements StaticMask {
+
+ private final double centerX;
+ private final double centerY;
+ private final double centerZ;
+ private final double radiusSqX;
+ private final double radiusSqY;
+ private final double radiusSqZ;
+ private final boolean filled;
+
+ public SphereMask(int widthX, int heightY, int lengthZ, boolean filled) {
+ super(widthX, heightY, lengthZ);
+ this.centerX = widthX / 2.0;
+ this.centerY = heightY / 2.0;
+ this.centerZ = lengthZ / 2.0;
+ this.radiusSqX = this.centerX * this.centerX;
+ this.radiusSqY = this.centerY * this.centerY;
+ this.radiusSqZ = this.centerZ * this.centerZ;
+ this.filled = filled;
+ }
+
+ @Override
+ public boolean partOfMask(int x, int y, int z) {
+ double dx = Math.abs((x + 0.5) - this.centerX);
+ double dy = Math.abs((y + 0.5) - this.centerY);
+ double dz = Math.abs((z + 0.5) - this.centerZ);
+ if (this.outside(dx, dy, dz)) {
+ return false;
+ }
+ return this.filled
+ || this.outside(dx + 1, dy, dz)
+ || this.outside(dx, dy + 1, dz)
+ || this.outside(dx, dy, dz + 1);
+ }
+
+ private boolean outside(double dx, double dy, double dz) {
+ return dx * dx / this.radiusSqX + dy * dy / this.radiusSqY + dz * dz / this.radiusSqZ > 1;
+ }
+}
diff --git a/src/api/java/baritone/api/utils/BetterBlockPos.java b/src/api/java/baritone/api/utils/BetterBlockPos.java
index cee7649b0..5add76555 100644
--- a/src/api/java/baritone/api/utils/BetterBlockPos.java
+++ b/src/api/java/baritone/api/utils/BetterBlockPos.java
@@ -34,6 +34,15 @@ import net.minecraft.util.Mth;
*/
public final class BetterBlockPos extends BlockPos {
+ private static final int NUM_X_BITS = 26;
+ private static final int NUM_Z_BITS = NUM_X_BITS;
+ private static final int NUM_Y_BITS = 64 - NUM_X_BITS - NUM_Z_BITS;
+ private static final int Y_SHIFT = NUM_Z_BITS;
+ private static final int X_SHIFT = Y_SHIFT + NUM_Y_BITS;
+ private static final long X_MASK = (1L << NUM_X_BITS) - 1L;
+ private static final long Y_MASK = (1L << NUM_Y_BITS) - 1L;
+ private static final long Z_MASK = (1L << NUM_Z_BITS) - 1L;
+
public static final BetterBlockPos ORIGIN = new BetterBlockPos(0, 0, 0);
public final int x;
@@ -201,6 +210,20 @@ public final class BetterBlockPos extends BlockPos {
return amt == 0 ? this : new BetterBlockPos(x - amt, y, z);
}
+ public double distanceSq(final BetterBlockPos to) {
+ double dx = (double) this.x - to.x;
+ double dy = (double) this.y - to.y;
+ double dz = (double) this.z - to.z;
+ return dx * dx + dy * dy + dz * dz;
+ }
+
+ public double distanceTo(final BetterBlockPos to) {
+ double dx = (double) this.x - to.x;
+ double dy = (double) this.y - to.y;
+ double dz = (double) this.z - to.z;
+ return Math.sqrt(dx * dx + dy * dy + dz * dz);
+ }
+
@Override
@Nonnull
public String toString() {
@@ -211,4 +234,15 @@ public final class BetterBlockPos extends BlockPos {
SettingsUtil.maybeCensor(z)
);
}
+
+ public static long serializeToLong(final int x, final int y, final int z) {
+ return ((long) x & X_MASK) << X_SHIFT | ((long) y & Y_MASK) << Y_SHIFT | ((long) z & Z_MASK);
+ }
+
+ public static BetterBlockPos deserializeFromLong(final long serialized) {
+ final int x = (int) (serialized << 64 - X_SHIFT - NUM_X_BITS >> 64 - NUM_X_BITS);
+ final int y = (int) (serialized << 64 - Y_SHIFT - NUM_Y_BITS >> 64 - NUM_Y_BITS);
+ final int z = (int) (serialized << 64 - NUM_Z_BITS >> 64 - NUM_Z_BITS);
+ return new BetterBlockPos(x, y, z);
+ }
}
diff --git a/src/api/java/baritone/api/utils/BlockOptionalMeta.java b/src/api/java/baritone/api/utils/BlockOptionalMeta.java
index 8723c3b51..038b63501 100644
--- a/src/api/java/baritone/api/utils/BlockOptionalMeta.java
+++ b/src/api/java/baritone/api/utils/BlockOptionalMeta.java
@@ -18,6 +18,7 @@
package baritone.api.utils;
import baritone.api.utils.accessor.IItemStack;
+import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import io.netty.util.concurrent.ThreadPerTaskExecutor;
import net.minecraft.client.Minecraft;
@@ -27,11 +28,11 @@ import net.minecraft.resources.ResourceLocation;
import net.minecraft.server.MinecraftServer;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.server.level.progress.ChunkProgressListener;
-import net.minecraft.server.packs.*;
+import net.minecraft.server.packs.PackType;
+import net.minecraft.server.packs.VanillaPackResources;
import net.minecraft.server.packs.repository.ServerPacksSource;
import net.minecraft.server.packs.resources.MultiPackResourceManager;
import net.minecraft.server.packs.resources.ReloadableResourceManager;
-import net.minecraft.util.RandomSource;
import net.minecraft.util.Unit;
import net.minecraft.world.RandomSequences;
import net.minecraft.world.flag.FeatureFlagSet;
@@ -41,6 +42,7 @@ import net.minecraft.world.level.CustomSpawner;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.Property;
import net.minecraft.world.level.dimension.LevelStem;
import net.minecraft.world.level.storage.LevelStorageSource;
import net.minecraft.world.level.storage.ServerLevelData;
@@ -60,44 +62,80 @@ import java.lang.reflect.Method;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;
-import java.util.regex.MatchResult;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
+import java.util.stream.Collectors;
public final class BlockOptionalMeta {
+ // id or id[] or id[properties] where id and properties are any text with at least one character
+ private static final Pattern PATTERN = Pattern.compile("^(?.+?)(?:\\[(?.+?)?\\])?$");
private final Block block;
+ private final String propertiesDescription; // exists so toString() can return something more useful than a list of all blockstates
private final Set blockstates;
private final ImmutableSet stateHashes;
private final ImmutableSet stackHashes;
- private static final Pattern pattern = Pattern.compile("^(.+?)(?::(\\d+))?$");
private static LootDataManager lootTables;
+
private static Map> drops = new HashMap<>();
public BlockOptionalMeta(@Nonnull Block block) {
this.block = block;
- this.blockstates = getStates(block);
+ this.propertiesDescription = "{}";
+ this.blockstates = getStates(block, Collections.emptyMap());
this.stateHashes = getStateHashes(blockstates);
this.stackHashes = getStackHashes(blockstates);
}
public BlockOptionalMeta(@Nonnull String selector) {
- Matcher matcher = pattern.matcher(selector);
+ Matcher matcher = PATTERN.matcher(selector);
if (!matcher.find()) {
throw new IllegalArgumentException("invalid block selector");
}
- MatchResult matchResult = matcher.toMatchResult();
+ block = BlockUtils.stringToBlockRequired(matcher.group("id"));
- block = BlockUtils.stringToBlockRequired(matchResult.group(1));
- blockstates = getStates(block);
+ String props = matcher.group("properties");
+ Map, ?> properties = props == null || props.equals("") ? Collections.emptyMap() : parseProperties(block, props);
+
+ propertiesDescription = props == null ? "{}" : "{" + props.replace("=", ":") + "}";
+ blockstates = getStates(block, properties);
stateHashes = getStateHashes(blockstates);
stackHashes = getStackHashes(blockstates);
}
- private static Set getStates(@Nonnull Block block) {
- return new HashSet<>(block.getStateDefinition().getPossibleStates());
+ private static , P extends Property> P castToIProperty(Object value) {
+ //noinspection unchecked
+ return (P) value;
+ }
+
+ private static Map, ?> parseProperties(Block block, String raw) {
+ ImmutableMap.Builder, Object> builder = ImmutableMap.builder();
+ for (String pair : raw.split(",")) {
+ String[] parts = pair.split("=");
+ if (parts.length != 2) {
+ throw new IllegalArgumentException(String.format("\"%s\" is not a valid property-value pair", pair));
+ }
+ String rawKey = parts[0];
+ String rawValue = parts[1];
+ Property key = block.getStateDefinition().getProperty(rawKey);
+ Comparable value = castToIProperty(key).getValue(rawValue)
+ .orElseThrow(() -> new IllegalArgumentException(String.format(
+ "\"%s\" is not a valid value for %s on %s",
+ rawValue, key, block
+ )));
+ builder.put(key, value);
+ }
+ return builder.build();
+ }
+
+ private static Set getStates(@Nonnull Block block, @Nonnull Map, ?> properties) {
+ return block.getStateDefinition().getPossibleStates().stream()
+ .filter(blockstate -> properties.entrySet().stream().allMatch(entry ->
+ blockstate.getValue(entry.getKey()) == entry.getValue()
+ ))
+ .collect(Collectors.toSet());
}
private static ImmutableSet getStateHashes(Set blockstates) {
@@ -145,7 +183,7 @@ public final class BlockOptionalMeta {
@Override
public String toString() {
- return String.format("BlockOptionalMeta{block=%s}", block);
+ return String.format("BlockOptionalMeta{block=%s,properties=%s}", block, propertiesDescription);
}
public BlockState getAnyBlockState() {
@@ -156,6 +194,14 @@ public final class BlockOptionalMeta {
return null;
}
+ public Set getAllBlockStates() {
+ return blockstates;
+ }
+
+ public Set stackHashes() {
+ return stackHashes;
+ }
+
private static Method getVanillaServerPack;
private static VanillaPackResources getVanillaServerPack() {
@@ -199,16 +245,16 @@ public final class BlockOptionalMeta {
try {
getManager().getLootTable(lootTableLocation).getRandomItemsRaw(
- new LootContext.Builder(
- new LootParams.Builder(ServerLevelStub.fastCreate())
- .withParameter(LootContextParams.ORIGIN, Vec3.atLowerCornerOf(BlockPos.ZERO))
- .withParameter(LootContextParams.TOOL, ItemStack.EMPTY)
- .withOptionalParameter(LootContextParams.BLOCK_ENTITY, null)
- .withParameter(LootContextParams.BLOCK_STATE, block.defaultBlockState())
- .create(LootContextParamSets.BLOCK)
+ new LootContext.Builder(
+ new LootParams.Builder(ServerLevelStub.fastCreate())
+ .withParameter(LootContextParams.ORIGIN, Vec3.atLowerCornerOf(BlockPos.ZERO))
+ .withParameter(LootContextParams.TOOL, ItemStack.EMPTY)
+ .withOptionalParameter(LootContextParams.BLOCK_ENTITY, null)
+ .withParameter(LootContextParams.BLOCK_STATE, block.defaultBlockState())
+ .create(LootContextParamSets.BLOCK)
).withOptionalRandomSeed(1L)
- .create(null),
- stack -> items.add(stack.getItem())
+ .create(null),
+ stack -> items.add(stack.getItem())
);
} catch (Exception e) {
e.printStackTrace();
diff --git a/src/api/java/baritone/api/utils/BlockOptionalMetaLookup.java b/src/api/java/baritone/api/utils/BlockOptionalMetaLookup.java
index 7c1070a84..7ab01cc87 100644
--- a/src/api/java/baritone/api/utils/BlockOptionalMetaLookup.java
+++ b/src/api/java/baritone/api/utils/BlockOptionalMetaLookup.java
@@ -17,67 +17,70 @@
package baritone.api.utils;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Stream;
+import baritone.api.utils.accessor.IItemStack;
+import com.google.common.collect.ImmutableSet;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.state.BlockState;
-public class BlockOptionalMetaLookup {
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Stream;
+public class BlockOptionalMetaLookup {
+ private final ImmutableSet blockSet;
+ private final ImmutableSet blockStateSet;
+ private final ImmutableSet stackHashes;
private final BlockOptionalMeta[] boms;
public BlockOptionalMetaLookup(BlockOptionalMeta... boms) {
this.boms = boms;
+ Set blocks = new HashSet<>();
+ Set blockStates = new HashSet<>();
+ Set stacks = new HashSet<>();
+ for (BlockOptionalMeta bom : boms) {
+ blocks.add(bom.getBlock());
+ blockStates.addAll(bom.getAllBlockStates());
+ stacks.addAll(bom.stackHashes());
+ }
+ this.blockSet = ImmutableSet.copyOf(blocks);
+ this.blockStateSet = ImmutableSet.copyOf(blockStates);
+ this.stackHashes = ImmutableSet.copyOf(stacks);
}
public BlockOptionalMetaLookup(Block... blocks) {
- this.boms = Stream.of(blocks)
+ this(Stream.of(blocks)
.map(BlockOptionalMeta::new)
- .toArray(BlockOptionalMeta[]::new);
+ .toArray(BlockOptionalMeta[]::new));
+
}
public BlockOptionalMetaLookup(List blocks) {
- this.boms = blocks.stream()
+ this(blocks.stream()
.map(BlockOptionalMeta::new)
- .toArray(BlockOptionalMeta[]::new);
+ .toArray(BlockOptionalMeta[]::new));
}
public BlockOptionalMetaLookup(String... blocks) {
- this.boms = Stream.of(blocks)
+ this(Stream.of(blocks)
.map(BlockOptionalMeta::new)
- .toArray(BlockOptionalMeta[]::new);
+ .toArray(BlockOptionalMeta[]::new));
}
public boolean has(Block block) {
- for (BlockOptionalMeta bom : boms) {
- if (bom.getBlock() == block) {
- return true;
- }
- }
-
- return false;
+ return blockSet.contains(block);
}
public boolean has(BlockState state) {
- for (BlockOptionalMeta bom : boms) {
- if (bom.matches(state)) {
- return true;
- }
- }
-
- return false;
+ return blockStateSet.contains(state);
}
public boolean has(ItemStack stack) {
- for (BlockOptionalMeta bom : boms) {
- if (bom.matches(stack)) {
- return true;
- }
- }
-
- return false;
+ int hash = ((IItemStack) (Object) stack).getBaritoneHash();
+ hash -= stack.getDamageValue();
+ return stackHashes.contains(hash);
}
public List blocks() {
diff --git a/src/api/java/baritone/api/utils/BooleanBinaryOperator.java b/src/api/java/baritone/api/utils/BooleanBinaryOperator.java
new file mode 100644
index 000000000..cfb85e644
--- /dev/null
+++ b/src/api/java/baritone/api/utils/BooleanBinaryOperator.java
@@ -0,0 +1,27 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.api.utils;
+
+/**
+ * @author Brady
+ */
+@FunctionalInterface
+public interface BooleanBinaryOperator {
+
+ boolean applyAsBoolean(boolean a, boolean b);
+}
diff --git a/src/api/java/baritone/api/utils/BooleanBinaryOperators.java b/src/api/java/baritone/api/utils/BooleanBinaryOperators.java
new file mode 100644
index 000000000..11605c965
--- /dev/null
+++ b/src/api/java/baritone/api/utils/BooleanBinaryOperators.java
@@ -0,0 +1,38 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.api.utils;
+
+/**
+ * @author Brady
+ */
+public enum BooleanBinaryOperators implements BooleanBinaryOperator {
+ OR((a, b) -> a || b),
+ AND((a, b) -> a && b),
+ XOR((a, b) -> a ^ b);
+
+ private final BooleanBinaryOperator op;
+
+ BooleanBinaryOperators(BooleanBinaryOperator op) {
+ this.op = op;
+ }
+
+ @Override
+ public boolean applyAsBoolean(boolean a, boolean b) {
+ return this.op.applyAsBoolean(a, b);
+ }
+}
diff --git a/src/api/java/baritone/api/utils/Helper.java b/src/api/java/baritone/api/utils/Helper.java
index 7e3c44607..507cd85a7 100755
--- a/src/api/java/baritone/api/utils/Helper.java
+++ b/src/api/java/baritone/api/utils/Helper.java
@@ -18,13 +18,13 @@
package baritone.api.utils;
import baritone.api.BaritoneAPI;
-import baritone.api.utils.gui.BaritoneToast;
+import baritone.api.Settings;
import net.minecraft.ChatFormatting;
+import net.minecraft.client.GuiMessageTag;
import net.minecraft.client.Minecraft;
import net.minecraft.network.chat.Component;
import net.minecraft.network.chat.MutableComponent;
-import java.awt.*;
import java.util.Arrays;
import java.util.Calendar;
import java.util.stream.Stream;
@@ -44,10 +44,17 @@ public interface Helper {
Helper HELPER = new Helper() {};
/**
- * Instance of the game
+ * The main game instance returned by {@link Minecraft#getInstance()}.
+ * Deprecated since {@link IPlayerContext#minecraft()} should be used instead (In the majority of cases).
*/
+ @Deprecated
Minecraft mc = Minecraft.getInstance();
+ /**
+ * The tag to assign to chat messages when {@link Settings#useMessageTag} is {@code true}.
+ */
+ GuiMessageTag MESSAGE_TAG = new GuiMessageTag(0xFF55FF, null, Component.literal("Baritone message."), "Baritone");
+
static Component getPrefix() {
// Inner text component
final Calendar now = Calendar.getInstance();
@@ -72,7 +79,7 @@ public interface Helper {
* @param message The message to display in the popup
*/
default void logToast(Component title, Component message) {
- mc.execute(() -> BaritoneAPI.getSettings().toaster.value.accept(title, message));
+ Minecraft.getInstance().execute(() -> BaritoneAPI.getSettings().toaster.value.accept(title, message));
}
/**
@@ -133,7 +140,7 @@ public interface Helper {
* @param error Whether to log as an error
*/
default void logNotificationDirect(String message, boolean error) {
- mc.execute(() -> BaritoneAPI.getSettings().notifier.value.accept(message, error));
+ Minecraft.getInstance().execute(() -> BaritoneAPI.getSettings().notifier.value.accept(message, error));
}
/**
@@ -160,13 +167,15 @@ public interface Helper {
*/
default void logDirect(boolean logAsToast, Component... components) {
MutableComponent component = Component.literal("");
- component.append(getPrefix());
- component.append(Component.literal(" "));
+ if (!logAsToast && !BaritoneAPI.getSettings().useMessageTag.value) {
+ component.append(getPrefix());
+ component.append(Component.literal(" "));
+ }
Arrays.asList(components).forEach(component::append);
if (logAsToast) {
logToast(getPrefix(), component);
} else {
- mc.execute(() -> BaritoneAPI.getSettings().logger.value.accept(component));
+ Minecraft.getInstance().execute(() -> BaritoneAPI.getSettings().logger.value.accept(component));
}
}
@@ -226,4 +235,11 @@ public interface Helper {
default void logDirect(String message) {
logDirect(message, BaritoneAPI.getSettings().logAsToast.value);
}
+
+ default void logUnhandledException(final Throwable exception) {
+ HELPER.logDirect("An unhandled exception occurred. " +
+ "The error is in your game's log, please report this at https://github.com/cabaletta/baritone/issues",
+ ChatFormatting.RED);
+ exception.printStackTrace();
+ }
}
diff --git a/src/api/java/baritone/api/utils/IPlayerContext.java b/src/api/java/baritone/api/utils/IPlayerContext.java
index 4e29b1459..a97475a5b 100644
--- a/src/api/java/baritone/api/utils/IPlayerContext.java
+++ b/src/api/java/baritone/api/utils/IPlayerContext.java
@@ -18,9 +18,7 @@
package baritone.api.utils;
import baritone.api.cache.IWorldData;
-import java.util.Optional;
-import java.util.stream.Stream;
-import java.util.stream.StreamSupport;
+import net.minecraft.client.Minecraft;
import net.minecraft.client.multiplayer.ClientLevel;
import net.minecraft.client.player.LocalPlayer;
import net.minecraft.core.BlockPos;
@@ -31,12 +29,18 @@ import net.minecraft.world.phys.BlockHitResult;
import net.minecraft.world.phys.HitResult;
import net.minecraft.world.phys.Vec3;
+import java.util.Optional;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
/**
* @author Brady
* @since 11/12/2018
*/
public interface IPlayerContext {
+ Minecraft minecraft();
+
LocalPlayer player();
IPlayerController playerController();
@@ -85,6 +89,12 @@ public interface IPlayerContext {
return new Vec3(player().position().x, player().position().y + player().getEyeHeight(), player().position().z);
}
+ default Vec3 playerMotion() {
+ return player().getDeltaMovement();
+ }
+
+ BetterBlockPos viewerPos();
+
default Rotation playerRotations() {
return new Rotation(player().getYRot(), player().getXRot());
}
diff --git a/src/api/java/baritone/api/utils/Pair.java b/src/api/java/baritone/api/utils/Pair.java
new file mode 100644
index 000000000..ca7259520
--- /dev/null
+++ b/src/api/java/baritone/api/utils/Pair.java
@@ -0,0 +1,59 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.api.utils;
+
+import java.util.Objects;
+
+/**
+ * @author Brady
+ */
+public final class Pair {
+
+ private final A a;
+ private final B b;
+
+ public Pair(A a, B b) {
+ this.a = a;
+ this.b = b;
+ }
+
+ public A first() {
+ return this.a;
+ }
+
+ public B second() {
+ return this.b;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || o.getClass() != Pair.class) {
+ return false;
+ }
+ Pair pair = (Pair) o;
+ return Objects.equals(this.a, pair.a) && Objects.equals(this.b, pair.b);
+ }
+
+ @Override
+ public int hashCode() {
+ return 31 * Objects.hashCode(this.a) + Objects.hashCode(this.b);
+ }
+}
diff --git a/src/api/java/baritone/api/utils/RayTraceUtils.java b/src/api/java/baritone/api/utils/RayTraceUtils.java
index 5c0a78f37..5541f562b 100644
--- a/src/api/java/baritone/api/utils/RayTraceUtils.java
+++ b/src/api/java/baritone/api/utils/RayTraceUtils.java
@@ -51,7 +51,8 @@ public final class RayTraceUtils {
} else {
start = entity.getEyePosition(1.0F); // do whatever is correct
}
- Vec3 direction = RotationUtils.calcVector3dFromRotation(rotation);
+
+ Vec3 direction = RotationUtils.calcLookDirectionFromRotation(rotation);
Vec3 end = start.add(
direction.x * blockReachDistance,
direction.y * blockReachDistance,
diff --git a/src/api/java/baritone/api/utils/Rotation.java b/src/api/java/baritone/api/utils/Rotation.java
index 36beea7bc..c75a9a559 100644
--- a/src/api/java/baritone/api/utils/Rotation.java
+++ b/src/api/java/baritone/api/utils/Rotation.java
@@ -26,12 +26,12 @@ public class Rotation {
/**
* The yaw angle of this Rotation
*/
- private float yaw;
+ private final float yaw;
/**
* The pitch angle of this Rotation
*/
- private float pitch;
+ private final float pitch;
public Rotation(float yaw, float pitch) {
this.yaw = yaw;
@@ -113,6 +113,10 @@ public class Rotation {
);
}
+ public Rotation withPitch(float pitch) {
+ return new Rotation(this.yaw, pitch);
+ }
+
/**
* Is really close to
*
diff --git a/src/api/java/baritone/api/utils/RotationUtils.java b/src/api/java/baritone/api/utils/RotationUtils.java
index 0a4fd8209..6e310bb1c 100644
--- a/src/api/java/baritone/api/utils/RotationUtils.java
+++ b/src/api/java/baritone/api/utils/RotationUtils.java
@@ -19,7 +19,6 @@ package baritone.api.utils;
import baritone.api.BaritoneAPI;
import baritone.api.IBaritone;
-import java.util.Optional;
import net.minecraft.client.player.LocalPlayer;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
@@ -33,6 +32,8 @@ import net.minecraft.world.phys.Vec3;
import net.minecraft.world.phys.shapes.Shapes;
import net.minecraft.world.phys.shapes.VoxelShape;
+import java.util.Optional;
+
/**
* @author Brady
* @since 9/25/2018
@@ -43,11 +44,13 @@ public final class RotationUtils {
* Constant that a degree value is multiplied by to get the equivalent radian value
*/
public static final double DEG_TO_RAD = Math.PI / 180.0;
+ public static final float DEG_TO_RAD_F = (float) DEG_TO_RAD;
/**
* Constant that a radian value is multiplied by to get the equivalent degree value
*/
public static final double RAD_TO_DEG = 180.0 / Math.PI;
+ public static final float RAD_TO_DEG_F = (float) RAD_TO_DEG;
/**
* Offsets from the root block position to the center of each side.
@@ -128,26 +131,31 @@ public final class RotationUtils {
* @param rotation The input rotation
* @return Look vector for the rotation
*/
- public static Vec3 calcVector3dFromRotation(Rotation rotation) {
- float f = Mth.cos(-rotation.getYaw() * (float) DEG_TO_RAD - (float) Math.PI);
- float f1 = Mth.sin(-rotation.getYaw() * (float) DEG_TO_RAD - (float) Math.PI);
- float f2 = -Mth.cos(-rotation.getPitch() * (float) DEG_TO_RAD);
- float f3 = Mth.sin(-rotation.getPitch() * (float) DEG_TO_RAD);
- return new Vec3((double) (f1 * f2), (double) f3, (double) (f * f2));
+ public static Vec3 calcLookDirectionFromRotation(Rotation rotation) {
+ float flatZ = Mth.cos((-rotation.getYaw() * DEG_TO_RAD_F) - (float) Math.PI);
+ float flatX = Mth.sin((-rotation.getYaw() * DEG_TO_RAD_F) - (float) Math.PI);
+ float pitchBase = -Mth.cos(-rotation.getPitch() * DEG_TO_RAD_F);
+ float pitchHeight = Mth.sin(-rotation.getPitch() * DEG_TO_RAD_F);
+ return new Vec3(flatX * pitchBase, pitchHeight, flatZ * pitchBase);
+ }
+
+ @Deprecated
+ public static Vec3 calcVec3dFromRotation(Rotation rotation) {
+ return calcLookDirectionFromRotation(rotation);
}
/**
* @param ctx Context for the viewing entity
* @param pos The target block position
* @return The optional rotation
- * @see #reachable(LocalPlayer, BlockPos, double)
+ * @see #reachable(IPlayerContext, BlockPos, double)
*/
public static Optional reachable(IPlayerContext ctx, BlockPos pos) {
- return reachable(ctx.player(), pos, ctx.playerController().getBlockReachDistance());
+ return reachable(ctx, pos, false);
}
public static Optional reachable(IPlayerContext ctx, BlockPos pos, boolean wouldSneak) {
- return reachable(ctx.player(), pos, ctx.playerController().getBlockReachDistance(), wouldSneak);
+ return reachable(ctx, pos, ctx.playerController().getBlockReachDistance(), wouldSneak);
}
/**
@@ -157,18 +165,17 @@ public final class RotationUtils {
* side that is reachable. The return type will be {@link Optional#empty()} if the entity is
* unable to reach any of the sides of the block.
*
- * @param entity The viewing entity
+ * @param ctx Context for the viewing entity
* @param pos The target block position
* @param blockReachDistance The block reach distance of the entity
* @return The optional rotation
*/
- public static Optional reachable(LocalPlayer entity, BlockPos pos, double blockReachDistance) {
- return reachable(entity, pos, blockReachDistance, false);
+ public static Optional reachable(IPlayerContext ctx, BlockPos pos, double blockReachDistance) {
+ return reachable(ctx, pos, blockReachDistance, false);
}
- public static Optional reachable(LocalPlayer entity, BlockPos pos, double blockReachDistance, boolean wouldSneak) {
- IBaritone baritone = BaritoneAPI.getProvider().getBaritoneForPlayer(entity);
- if (baritone.getPlayerContext().isLookingAt(pos)) {
+ public static Optional reachable(IPlayerContext ctx, BlockPos pos, double blockReachDistance, boolean wouldSneak) {
+ if (BaritoneAPI.getSettings().remainWithExistingLookDirection.value && ctx.isLookingAt(pos)) {
/*
* why add 0.0001?
* to indicate that we actually have a desired pitch
@@ -179,10 +186,10 @@ public final class RotationUtils {
*
* or if you're a normal person literally all this does it ensure that we don't nudge the pitch to a normal level
*/
- Rotation hypothetical = new Rotation(entity.getYRot(), entity.getXRot() + 0.0001F);
+ Rotation hypothetical = ctx.playerRotations().add(new Rotation(0, 0.0001F));
if (wouldSneak) {
// the concern here is: what if we're looking at it now, but as soon as we start sneaking we no longer are
- HitResult result = RayTraceUtils.rayTraceTowards(entity, hypothetical, blockReachDistance, true);
+ HitResult result = RayTraceUtils.rayTraceTowards(ctx.player(), hypothetical, blockReachDistance, true);
if (result != null && result.getType() == HitResult.Type.BLOCK && ((BlockHitResult) result).getBlockPos().equals(pos)) {
return Optional.of(hypothetical); // yes, if we sneaked we would still be looking at the block
}
@@ -190,14 +197,14 @@ public final class RotationUtils {
return Optional.of(hypothetical);
}
}
- Optional possibleRotation = reachableCenter(entity, pos, blockReachDistance, wouldSneak);
+ Optional possibleRotation = reachableCenter(ctx, pos, blockReachDistance, wouldSneak);
//System.out.println("center: " + possibleRotation);
if (possibleRotation.isPresent()) {
return possibleRotation;
}
- BlockState state = entity.level().getBlockState(pos);
- VoxelShape shape = state.getShape(entity.level(), pos);
+ BlockState state = ctx.world().getBlockState(pos);
+ VoxelShape shape = state.getShape(ctx.world(), pos);
if (shape.isEmpty()) {
shape = Shapes.block();
}
@@ -205,7 +212,7 @@ public final class RotationUtils {
double xDiff = shape.min(Direction.Axis.X) * sideOffset.x + shape.max(Direction.Axis.X) * (1 - sideOffset.x);
double yDiff = shape.min(Direction.Axis.Y) * sideOffset.y + shape.max(Direction.Axis.Y) * (1 - sideOffset.y);
double zDiff = shape.min(Direction.Axis.Z) * sideOffset.z + shape.max(Direction.Axis.Z) * (1 - sideOffset.z);
- possibleRotation = reachableOffset(entity, pos, new Vec3(pos.getX(), pos.getY(), pos.getZ()).add(xDiff, yDiff, zDiff), blockReachDistance, wouldSneak);
+ possibleRotation = reachableOffset(ctx, pos, new Vec3(pos.getX(), pos.getY(), pos.getZ()).add(xDiff, yDiff, zDiff), blockReachDistance, wouldSneak);
if (possibleRotation.isPresent()) {
return possibleRotation;
}
@@ -218,12 +225,55 @@ public final class RotationUtils {
* the given offsetted position. The return type will be {@link Optional#empty()} if
* the entity is unable to reach the block with the offset applied.
*
- * @param entity The viewing entity
+ * @param ctx Context for the viewing entity
* @param pos The target block position
* @param offsetPos The position of the block with the offset applied.
* @param blockReachDistance The block reach distance of the entity
* @return The optional rotation
*/
+ public static Optional reachableOffset(IPlayerContext ctx, BlockPos pos, Vec3 offsetPos, double blockReachDistance, boolean wouldSneak) {
+ Vec3 eyes = wouldSneak ? RayTraceUtils.inferSneakingEyePosition(ctx.player()) : ctx.player().getEyePosition(1.0F);
+ Rotation rotation = calcRotationFromVec3d(eyes, offsetPos, ctx.playerRotations());
+ Rotation actualRotation = BaritoneAPI.getProvider().getBaritoneForPlayer(ctx.player()).getLookBehavior().getAimProcessor().peekRotation(rotation);
+ HitResult result = RayTraceUtils.rayTraceTowards(ctx.player(), actualRotation, blockReachDistance, wouldSneak);
+ //System.out.println(result);
+ if (result != null && result.getType() == HitResult.Type.BLOCK) {
+ if (((BlockHitResult) result).getBlockPos().equals(pos)) {
+ return Optional.of(rotation);
+ }
+ if (ctx.world().getBlockState(pos).getBlock() instanceof BaseFireBlock && ((BlockHitResult) result).getBlockPos().equals(pos.below())) {
+ return Optional.of(rotation);
+ }
+ }
+ return Optional.empty();
+ }
+
+ /**
+ * Determines if the specified entity is able to reach the specified block where it is
+ * looking at the direct center of it's hitbox.
+ *
+ * @param ctx Context for the viewing entity
+ * @param pos The target block position
+ * @param blockReachDistance The block reach distance of the entity
+ * @return The optional rotation
+ */
+ public static Optional reachableCenter(IPlayerContext ctx, BlockPos pos, double blockReachDistance, boolean wouldSneak) {
+ return reachableOffset(ctx, pos, VecUtils.calculateBlockCenter(ctx.world(), pos), blockReachDistance, wouldSneak);
+ }
+
+ @Deprecated
+ public static Optional reachable(LocalPlayer entity, BlockPos pos, double blockReachDistance) {
+ return reachable(entity, pos, blockReachDistance, false);
+ }
+
+ @Deprecated
+ public static Optional reachable(LocalPlayer entity, BlockPos pos, double blockReachDistance, boolean wouldSneak) {
+ IBaritone baritone = BaritoneAPI.getProvider().getBaritoneForPlayer(entity);
+ IPlayerContext ctx = baritone.getPlayerContext();
+ return reachable(ctx, pos, blockReachDistance, wouldSneak);
+ }
+
+ @Deprecated
public static Optional reachableOffset(Entity entity, BlockPos pos, Vec3 offsetPos, double blockReachDistance, boolean wouldSneak) {
Vec3 eyes = wouldSneak ? RayTraceUtils.inferSneakingEyePosition(entity) : entity.getEyePosition(1.0F);
Rotation rotation = calcRotationFromVec3d(eyes, offsetPos, new Rotation(entity.getYRot(), entity.getXRot()));
@@ -240,15 +290,7 @@ public final class RotationUtils {
return Optional.empty();
}
- /**
- * Determines if the specified entity is able to reach the specified block where it is
- * looking at the direct center of it's hitbox.
- *
- * @param entity The viewing entity
- * @param pos The target block position
- * @param blockReachDistance The block reach distance of the entity
- * @return The optional rotation
- */
+ @Deprecated
public static Optional reachableCenter(Entity entity, BlockPos pos, double blockReachDistance, boolean wouldSneak) {
return reachableOffset(entity, pos, VecUtils.calculateBlockCenter(entity.level(), pos), blockReachDistance, wouldSneak);
}
diff --git a/src/api/java/baritone/api/utils/SettingsUtil.java b/src/api/java/baritone/api/utils/SettingsUtil.java
index 9e82c05de..53283cd33 100644
--- a/src/api/java/baritone/api/utils/SettingsUtil.java
+++ b/src/api/java/baritone/api/utils/SettingsUtil.java
@@ -47,12 +47,10 @@ import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;
-
public class SettingsUtil {
- private static final Path SETTINGS_PATH = Minecraft.getInstance().gameDirectory.toPath().resolve("baritone").resolve("settings.txt");
+ public static final String SETTINGS_DEFAULT_NAME = "settings.txt";
private static final Pattern SETTING_PATTERN = Pattern.compile("^(?[^ ]+) +(?.+)"); // key and value split by the first space
- private static final String[] JAVA_ONLY_SETTINGS = {"logger", "notifier", "toaster"};
private static boolean isComment(String line) {
@@ -71,12 +69,12 @@ public class SettingsUtil {
}
}
- public static void readAndApply(Settings settings) {
+ public static void readAndApply(Settings settings, String settingsName) {
try {
- forEachLine(SETTINGS_PATH, line -> {
+ forEachLine(settingsByName(settingsName), line -> {
Matcher matcher = SETTING_PATTERN.matcher(line);
if (!matcher.matches()) {
- System.out.println("Invalid syntax in setting file: " + line);
+ Helper.HELPER.logDirect("Invalid syntax in setting file: " + line);
return;
}
@@ -85,29 +83,33 @@ public class SettingsUtil {
try {
parseAndApply(settings, settingName, settingValue);
} catch (Exception ex) {
- System.out.println("Unable to parse line " + line);
+ Helper.HELPER.logDirect("Unable to parse line " + line);
ex.printStackTrace();
}
});
} catch (NoSuchFileException ignored) {
- System.out.println("Baritone settings file not found, resetting.");
+ Helper.HELPER.logDirect("Baritone settings file not found, resetting.");
} catch (Exception ex) {
- System.out.println("Exception while reading Baritone settings, some settings may be reset to default values!");
+ Helper.HELPER.logDirect("Exception while reading Baritone settings, some settings may be reset to default values!");
ex.printStackTrace();
}
}
public static synchronized void save(Settings settings) {
- try (BufferedWriter out = Files.newBufferedWriter(SETTINGS_PATH)) {
+ try (BufferedWriter out = Files.newBufferedWriter(settingsByName(SETTINGS_DEFAULT_NAME))) {
for (Settings.Setting setting : modifiedSettings(settings)) {
out.write(settingToString(setting) + "\n");
}
} catch (Exception ex) {
- System.out.println("Exception thrown while saving Baritone settings!");
+ Helper.HELPER.logDirect("Exception thrown while saving Baritone settings!");
ex.printStackTrace();
}
}
+ private static Path settingsByName(String name) {
+ return Minecraft.getInstance().gameDirectory.toPath().resolve("baritone").resolve(name);
+ }
+
public static List modifiedSettings(Settings settings) {
List modified = new ArrayList<>();
for (Settings.Setting setting : settings.allSettings) {
@@ -115,7 +117,7 @@ public class SettingsUtil {
System.out.println("NULL SETTING?" + setting.getName());
continue;
}
- if (javaOnlySetting(setting)) {
+ if (setting.isJavaOnly()) {
continue; // NO
}
if (setting.value == setting.defaultValue) {
@@ -169,7 +171,7 @@ public class SettingsUtil {
}
public static String settingToString(Settings.Setting setting) throws IllegalStateException {
- if (javaOnlySetting(setting)) {
+ if (setting.isJavaOnly()) {
return setting.getName();
}
@@ -177,18 +179,14 @@ public class SettingsUtil {
}
/**
- * This should always be the same as whether the setting can be parsed from or serialized to a string
+ * Deprecated. Use {@link Settings.Setting#isJavaOnly()} instead.
*
* @param setting The Setting
* @return true if the setting can not be set or read by the user
*/
+ @Deprecated
public static boolean javaOnlySetting(Settings.Setting setting) {
- for (String name : JAVA_ONLY_SETTINGS) { // no JAVA_ONLY_SETTINGS.contains(...) because that would be case sensitive
- if (setting.getName().equalsIgnoreCase(name)) {
- return true;
- }
- }
- return false;
+ return setting.isJavaOnly();
}
public static void parseAndApply(Settings settings, String settingName, String settingValue) throws IllegalStateException, NumberFormatException {
diff --git a/src/launch/java/baritone/launch/mixins/MixinClientPlayNetHandler.java b/src/launch/java/baritone/launch/mixins/MixinClientPlayNetHandler.java
index e718685c9..6b4564aa9 100644
--- a/src/launch/java/baritone/launch/mixins/MixinClientPlayNetHandler.java
+++ b/src/launch/java/baritone/launch/mixins/MixinClientPlayNetHandler.java
@@ -20,16 +20,19 @@ package baritone.launch.mixins;
import baritone.Baritone;
import baritone.api.BaritoneAPI;
import baritone.api.IBaritone;
+import baritone.api.event.events.BlockChangeEvent;
import baritone.api.event.events.ChatEvent;
import baritone.api.event.events.ChunkEvent;
import baritone.api.event.events.type.EventState;
+import baritone.api.utils.Pair;
import baritone.cache.CachedChunk;
import net.minecraft.client.Minecraft;
import net.minecraft.client.multiplayer.ClientPacketListener;
import net.minecraft.client.player.LocalPlayer;
-import net.minecraft.network.chat.Component;
+import net.minecraft.core.BlockPos;
import net.minecraft.network.protocol.game.*;
import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.block.state.BlockState;
import org.spongepowered.asm.mixin.Final;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
@@ -37,6 +40,9 @@ import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import java.util.ArrayList;
+import java.util.List;
+
/**
* @author Brady
* @since 8/3/2018
@@ -68,12 +74,14 @@ public class MixinClientPlayNetHandler {
}
}*/
- @Shadow @Final private Minecraft minecraft;
+ @Shadow
+ @Final
+ private Minecraft minecraft;
@Inject(
- method = "sendChat(Ljava/lang/String;)V",
- at = @At("HEAD"),
- cancellable = true
+ method = "sendChat(Ljava/lang/String;)V",
+ at = @At("HEAD"),
+ cancellable = true
)
private void sendChatMessage(String string, CallbackInfo ci) {
ChatEvent event = new ChatEvent(string);
@@ -168,31 +176,22 @@ public class MixinClientPlayNetHandler {
at = @At("RETURN")
)
private void postHandleMultiBlockChange(ClientboundSectionBlocksUpdatePacket packetIn, CallbackInfo ci) {
- if (!Baritone.settings().repackOnAnyBlockChange.value) {
+ IBaritone baritone = BaritoneAPI.getProvider().getBaritoneForConnection((ClientPacketListener) (Object) this);
+ if (baritone == null) {
return;
}
- ChunkPos[] chunkPos = new ChunkPos[1];
- packetIn.runUpdates((pos, state) -> {
- if (CachedChunk.BLOCKS_TO_KEEP_TRACK_OF.contains(state.getBlock())) {
- chunkPos[0] = new ChunkPos(pos);
- }
+
+ List> changes = new ArrayList<>();
+ packetIn.runUpdates((mutPos, state) -> {
+ changes.add(new Pair<>(mutPos.immutable(), state));
});
- if (chunkPos[0] == null) {
+ if (changes.isEmpty()) {
return;
}
- for (IBaritone ibaritone : BaritoneAPI.getProvider().getAllBaritones()) {
- LocalPlayer player = ibaritone.getPlayerContext().player();
- if (player != null && player.connection == (ClientPacketListener) (Object) this) {
- ibaritone.getGameEventHandler().onChunkEvent(
- new ChunkEvent(
- EventState.POST,
- ChunkEvent.Type.POPULATE_FULL,
- chunkPos[0].x,
- chunkPos[0].z
- )
- );
- }
- }
+ baritone.getGameEventHandler().onBlockChange(new BlockChangeEvent(
+ new ChunkPos(changes.get(0).first()),
+ changes
+ ));
}
@Inject(
@@ -210,4 +209,71 @@ public class MixinClientPlayNetHandler {
}
}
}
+
+ /*
+ @Inject(
+ method = "handleChunkData",
+ at = @At(
+ value = "INVOKE",
+ target = "net/minecraft/world/chunk/Chunk.read(Lnet/minecraft/network/PacketBuffer;IZ)V"
+ )
+ )
+ private void preRead(SPacketChunkData packetIn, CallbackInfo ci) {
+ IBaritone baritone = BaritoneAPI.getProvider().getBaritoneForConnection((NetHandlerPlayClient) (Object) this);
+ if (baritone == null) {
+ return;
+ }
+ baritone.getGameEventHandler().onChunkEvent(
+ new ChunkEvent(
+ EventState.PRE,
+ packetIn.isFullChunk() ? ChunkEvent.Type.POPULATE_FULL : ChunkEvent.Type.POPULATE_PARTIAL,
+ packetIn.getChunkX(),
+ packetIn.getChunkZ()
+ )
+ );
+ }
+
+ @Inject(
+ method = "handleChunkData",
+ at = @At("RETURN")
+ )
+ private void postHandleChunkData(SPacketChunkData packetIn, CallbackInfo ci) {
+ IBaritone baritone = BaritoneAPI.getProvider().getBaritoneForConnection((NetHandlerPlayClient) (Object) this);
+ if (baritone == null) {
+ return;
+ }
+ baritone.getGameEventHandler().onChunkEvent(
+ new ChunkEvent(
+ EventState.POST,
+ packetIn.isFullChunk() ? ChunkEvent.Type.POPULATE_FULL : ChunkEvent.Type.POPULATE_PARTIAL,
+ packetIn.getChunkX(),
+ packetIn.getChunkZ()
+ )
+ );
+ }
+
+ @Inject(
+ method = "handleBlockChange",
+ at = @At("RETURN")
+ )
+ private void postHandleBlockChange(SPacketBlockChange packetIn, CallbackInfo ci) {
+ IBaritone baritone = BaritoneAPI.getProvider().getBaritoneForConnection((NetHandlerPlayClient) (Object) this);
+ if (baritone == null) {
+ return;
+ }
+
+ final ChunkPos pos = new ChunkPos(packetIn.getBlockPosition().getX() >> 4, packetIn.getBlockPosition().getZ() >> 4);
+ final Pair changed = new Pair<>(packetIn.getBlockPosition(), packetIn.getBlockState());
+ baritone.getGameEventHandler().onBlockChange(new BlockChangeEvent(pos, Collections.singletonList(changed)));
+ }
+
+ @Inject(
+ method = "handleMultiBlockChange",
+ at = @At("RETURN")
+ )
+ private void postHandleMultiBlockChange(SPacketMultiBlockChange packetIn, CallbackInfo ci) {
+
+ }
+
+ */
}
diff --git a/src/launch/java/baritone/launch/mixins/MixinClientPlayerEntity.java b/src/launch/java/baritone/launch/mixins/MixinClientPlayerEntity.java
index 22ca083e0..4674ffaa6 100644
--- a/src/launch/java/baritone/launch/mixins/MixinClientPlayerEntity.java
+++ b/src/launch/java/baritone/launch/mixins/MixinClientPlayerEntity.java
@@ -19,15 +19,15 @@ package baritone.launch.mixins;
import baritone.api.BaritoneAPI;
import baritone.api.IBaritone;
-import baritone.api.event.events.ChatEvent;
import baritone.api.event.events.PlayerUpdateEvent;
import baritone.api.event.events.SprintStateEvent;
import baritone.api.event.events.type.EventState;
import baritone.behavior.LookBehavior;
import net.minecraft.client.KeyMapping;
import net.minecraft.client.player.LocalPlayer;
-import net.minecraft.network.chat.Component;
import net.minecraft.world.entity.player.Abilities;
+import net.minecraft.world.item.ElytraItem;
+import net.minecraft.world.item.ItemStack;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
@@ -45,9 +45,8 @@ public class MixinClientPlayerEntity {
method = "tick",
at = @At(
value = "INVOKE",
- target = "net/minecraft/client/player/LocalPlayer.isPassenger()Z",
- shift = At.Shift.BY,
- by = -3
+ target = "net/minecraft/client/player/AbstractClientPlayer.tick()V",
+ shift = At.Shift.AFTER
)
)
private void onPreUpdate(CallbackInfo ci) {
@@ -57,22 +56,6 @@ public class MixinClientPlayerEntity {
}
}
- @Inject(
- method = "tick",
- at = @At(
- value = "INVOKE",
- target = "net/minecraft/client/player/LocalPlayer.sendPosition()V",
- shift = At.Shift.BY,
- by = 2
- )
- )
- private void onPostUpdate(CallbackInfo ci) {
- IBaritone baritone = BaritoneAPI.getProvider().getBaritoneForPlayer((LocalPlayer) (Object) this);
- if (baritone != null) {
- baritone.getGameEventHandler().onPlayerUpdate(new PlayerUpdateEvent(EventState.POST));
- }
- }
-
@Redirect(
method = "aiStep",
at = @At(
@@ -124,4 +107,19 @@ public class MixinClientPlayerEntity {
((LookBehavior) baritone.getLookBehavior()).pig();
}
}
+
+ @Redirect(
+ method = "aiStep",
+ at = @At(
+ value = "INVOKE",
+ target = "net/minecraft/world/item/ElytraItem.isFlyEnabled(Lnet/minecraft/world/item/ItemStack;)Z"
+ )
+ )
+ private boolean isFlyEnabled(ItemStack stack) {
+ IBaritone baritone = BaritoneAPI.getProvider().getBaritoneForPlayer((LocalPlayer) (Object) this);
+ if (baritone != null && baritone.getPathingBehavior().isPathing()) {
+ return false;
+ }
+ return ElytraItem.isFlyEnabled(stack);
+ }
}
diff --git a/src/launch/java/baritone/launch/mixins/MixinCommandSuggestionHelper.java b/src/launch/java/baritone/launch/mixins/MixinCommandSuggestionHelper.java
index 63331502f..2bcdb2d78 100644
--- a/src/launch/java/baritone/launch/mixins/MixinCommandSuggestionHelper.java
+++ b/src/launch/java/baritone/launch/mixins/MixinCommandSuggestionHelper.java
@@ -19,9 +19,12 @@ package baritone.launch.mixins;
import baritone.api.BaritoneAPI;
import baritone.api.event.events.TabCompleteEvent;
+import com.mojang.brigadier.ParseResults;
import com.mojang.brigadier.context.StringRange;
import com.mojang.brigadier.suggestion.Suggestion;
import com.mojang.brigadier.suggestion.Suggestions;
+import net.minecraft.client.gui.components.CommandSuggestions;
+import net.minecraft.client.gui.components.EditBox;
import org.spongepowered.asm.mixin.Final;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
@@ -33,8 +36,6 @@ import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;
import java.util.stream.Stream;
-import net.minecraft.client.gui.components.CommandSuggestions;
-import net.minecraft.client.gui.components.EditBox;
/**
* @author Brady
@@ -51,9 +52,18 @@ public class MixinCommandSuggestionHelper {
@Final
private List commandUsage;
+ @Shadow
+ private ParseResults currentParse;
+
@Shadow
private CompletableFuture pendingSuggestions;
+ @Shadow
+ private CommandSuggestions.SuggestionsList suggestions;
+
+ @Shadow
+ boolean keepSuggestions;
+
@Inject(
method = "updateCommandInfo",
at = @At("HEAD"),
@@ -74,27 +84,32 @@ public class MixinCommandSuggestionHelper {
if (event.completions != null) {
ci.cancel();
+ this.currentParse = null; // stop coloring
+
+ if (this.keepSuggestions) { // Supress suggestions update when cycling suggestions.
+ return;
+ }
+
+ this.input.setSuggestion(null); // clear old suggestions
+ this.suggestions = null;
// TODO: Support populating the command usage
this.commandUsage.clear();
if (event.completions.length == 0) {
this.pendingSuggestions = Suggestions.empty();
} else {
- int offset = this.input.getValue().endsWith(" ")
- ? this.input.getCursorPosition()
- : this.input.getValue().lastIndexOf(" ") + 1; // If there is no space this is still 0 haha yes
+ StringRange range = StringRange.between(prefix.lastIndexOf(" ") + 1, prefix.length()); // if there is no space this starts at 0
List suggestionList = Stream.of(event.completions)
- .map(s -> new Suggestion(StringRange.between(offset, offset + s.length()), s))
+ .map(s -> new Suggestion(range, s))
.collect(Collectors.toList());
- Suggestions suggestions = new Suggestions(
- StringRange.between(offset, offset + suggestionList.stream().mapToInt(s -> s.getText().length()).max().orElse(0)),
- suggestionList);
+ Suggestions suggestions = new Suggestions(range, suggestionList);
this.pendingSuggestions = new CompletableFuture<>();
this.pendingSuggestions.complete(suggestions);
}
+ ((CommandSuggestions) (Object) this).showSuggestions(true); // actually populate the suggestions list from the suggestions future
}
}
}
diff --git a/src/launch/java/baritone/launch/mixins/MixinEntity.java b/src/launch/java/baritone/launch/mixins/MixinEntity.java
index b48e919f2..748095351 100644
--- a/src/launch/java/baritone/launch/mixins/MixinEntity.java
+++ b/src/launch/java/baritone/launch/mixins/MixinEntity.java
@@ -23,6 +23,7 @@ import net.minecraft.client.player.LocalPlayer;
import net.minecraft.world.entity.Entity;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
@@ -33,21 +34,25 @@ public class MixinEntity {
@Shadow
private float yRot;
- float yawRestore;
+ @Shadow
+ private float xRot;
+
+ @Unique
+ private RotationMoveEvent motionUpdateRotationEvent;
@Inject(
method = "moveRelative",
at = @At("HEAD")
)
private void moveRelativeHead(CallbackInfo info) {
- this.yawRestore = this.yRot;
// noinspection ConstantConditions
if (!LocalPlayer.class.isInstance(this) || BaritoneAPI.getProvider().getBaritoneForPlayer((LocalPlayer) (Object) this) == null) {
return;
}
- RotationMoveEvent motionUpdateRotationEvent = new RotationMoveEvent(RotationMoveEvent.Type.MOTION_UPDATE, this.yRot);
+ this.motionUpdateRotationEvent = new RotationMoveEvent(RotationMoveEvent.Type.MOTION_UPDATE, this.yRot, this.xRot);
BaritoneAPI.getProvider().getBaritoneForPlayer((LocalPlayer) (Object) this).getGameEventHandler().onPlayerRotationMove(motionUpdateRotationEvent);
- this.yRot = motionUpdateRotationEvent.getYaw();
+ this.yRot = this.motionUpdateRotationEvent.getYaw();
+ this.xRot = this.motionUpdateRotationEvent.getPitch();
}
@Inject(
@@ -55,6 +60,10 @@ public class MixinEntity {
at = @At("RETURN")
)
private void moveRelativeReturn(CallbackInfo info) {
- this.yRot = this.yawRestore;
+ if (this.motionUpdateRotationEvent != null) {
+ this.yRot = this.motionUpdateRotationEvent.getOriginal().getYaw();
+ this.xRot = this.motionUpdateRotationEvent.getOriginal().getPitch();
+ this.motionUpdateRotationEvent = null;
+ }
}
}
diff --git a/src/launch/java/baritone/launch/mixins/MixinFireworkRocketEntity.java b/src/launch/java/baritone/launch/mixins/MixinFireworkRocketEntity.java
new file mode 100644
index 000000000..b4c8e05b6
--- /dev/null
+++ b/src/launch/java/baritone/launch/mixins/MixinFireworkRocketEntity.java
@@ -0,0 +1,60 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.launch.mixins;
+
+import baritone.utils.accessor.IFireworkRocketEntity;
+import net.minecraft.network.syncher.EntityDataAccessor;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.projectile.FireworkRocketEntity;
+import net.minecraft.world.level.Level;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+
+import java.util.OptionalInt;
+
+@Mixin(FireworkRocketEntity.class)
+public abstract class MixinFireworkRocketEntity extends Entity implements IFireworkRocketEntity {
+
+ @Shadow
+ @Final
+ private static EntityDataAccessor DATA_ATTACHED_TO_TARGET;
+
+ @Shadow
+ private LivingEntity attachedToEntity;
+
+ @Shadow
+ public abstract boolean isAttachedToEntity();
+
+ private MixinFireworkRocketEntity(Level level) {
+ super(EntityType.FIREWORK_ROCKET, level);
+ }
+
+ @Override
+ public LivingEntity getBoostedEntity() {
+ if (this.isAttachedToEntity() && this.attachedToEntity == null) { // isAttachedToEntity checks if the optional is present
+ final Entity entity = this.level().getEntity(this.entityData.get(DATA_ATTACHED_TO_TARGET).getAsInt());
+ if (entity instanceof LivingEntity) {
+ this.attachedToEntity = (LivingEntity) entity;
+ }
+ }
+ return this.attachedToEntity;
+ }
+}
diff --git a/src/launch/java/baritone/launch/mixins/MixinLivingEntity.java b/src/launch/java/baritone/launch/mixins/MixinLivingEntity.java
index 44a5c1e32..ada92f6c2 100644
--- a/src/launch/java/baritone/launch/mixins/MixinLivingEntity.java
+++ b/src/launch/java/baritone/launch/mixins/MixinLivingEntity.java
@@ -25,13 +25,15 @@ import net.minecraft.world.entity.Entity;
import net.minecraft.world.entity.EntityType;
import net.minecraft.world.entity.LivingEntity;
import net.minecraft.world.level.Level;
+import net.minecraft.world.phys.Vec3;
import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Unique;
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 static org.objectweb.asm.Opcodes.GETFIELD;
+import java.util.Optional;
/**
* @author Brady
@@ -43,9 +45,13 @@ public abstract class MixinLivingEntity extends Entity {
/**
* Event called to override the movement direction when jumping
*/
+ @Unique
private RotationMoveEvent jumpRotationEvent;
- public MixinLivingEntity(EntityType entityTypeIn, Level worldIn) {
+ @Unique
+ private RotationMoveEvent elytraRotationEvent;
+
+ private MixinLivingEntity(EntityType entityTypeIn, Level worldIn) {
super(entityTypeIn, worldIn);
}
@@ -54,14 +60,10 @@ public abstract class MixinLivingEntity extends Entity {
at = @At("HEAD")
)
private void preMoveRelative(CallbackInfo ci) {
- // noinspection ConstantConditions
- if (LocalPlayer.class.isInstance(this)) {
- IBaritone baritone = BaritoneAPI.getProvider().getBaritoneForPlayer((LocalPlayer) (Object) this);
- if (baritone != null) {
- this.jumpRotationEvent = new RotationMoveEvent(RotationMoveEvent.Type.JUMP, this.getYRot());
- baritone.getGameEventHandler().onPlayerRotationMove(this.jumpRotationEvent);
- }
- }
+ this.getBaritone().ifPresent(baritone -> {
+ this.jumpRotationEvent = new RotationMoveEvent(RotationMoveEvent.Type.JUMP, this.getYRot(), this.getXRot());
+ baritone.getGameEventHandler().onPlayerRotationMove(this.jumpRotationEvent);
+ });
}
@Redirect(
@@ -78,5 +80,45 @@ public abstract class MixinLivingEntity extends Entity {
return self.getYRot();
}
+ @Inject(
+ method = "travel",
+ at = @At(
+ value = "INVOKE",
+ target = "net/minecraft/world/entity/LivingEntity.getLookAngle()Lnet/minecraft/world/phys/Vec3;"
+ )
+ )
+ private void onPreElytraMove(Vec3 direction, CallbackInfo ci) {
+ this.getBaritone().ifPresent(baritone -> {
+ this.elytraRotationEvent = new RotationMoveEvent(RotationMoveEvent.Type.MOTION_UPDATE, this.getYRot(), this.getXRot());
+ baritone.getGameEventHandler().onPlayerRotationMove(this.elytraRotationEvent);
+ this.setYRot(this.elytraRotationEvent.getYaw());
+ this.setXRot(this.elytraRotationEvent.getPitch());
+ });
+ }
+ @Inject(
+ method = "travel",
+ at = @At(
+ value = "INVOKE",
+ target = "net/minecraft/world/entity/LivingEntity.move(Lnet/minecraft/world/entity/MoverType;Lnet/minecraft/world/phys/Vec3;)V",
+ shift = At.Shift.AFTER
+ )
+ )
+ private void onPostElytraMove(Vec3 direction, CallbackInfo ci) {
+ if (this.elytraRotationEvent != null) {
+ this.setYRot(this.elytraRotationEvent.getOriginal().getYaw());
+ this.setXRot(this.elytraRotationEvent.getOriginal().getPitch());
+ this.elytraRotationEvent = null;
+ }
+ }
+
+ @Unique
+ private Optional getBaritone() {
+ // noinspection ConstantConditions
+ if (LocalPlayer.class.isInstance(this)) {
+ return Optional.ofNullable(BaritoneAPI.getProvider().getBaritoneForPlayer((LocalPlayer) (Object) this));
+ } else {
+ return Optional.empty();
+ }
+ }
}
diff --git a/src/launch/java/baritone/launch/mixins/MixinMinecraft.java b/src/launch/java/baritone/launch/mixins/MixinMinecraft.java
index 660292a19..17aece562 100644
--- a/src/launch/java/baritone/launch/mixins/MixinMinecraft.java
+++ b/src/launch/java/baritone/launch/mixins/MixinMinecraft.java
@@ -19,6 +19,7 @@ package baritone.launch.mixins;
import baritone.api.BaritoneAPI;
import baritone.api.IBaritone;
+import baritone.api.event.events.PlayerUpdateEvent;
import baritone.api.event.events.TickEvent;
import baritone.api.event.events.WorldEvent;
import baritone.api.event.events.type.EventState;
@@ -29,6 +30,7 @@ import net.minecraft.client.player.LocalPlayer;
import org.objectweb.asm.Opcodes;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.Redirect;
@@ -49,6 +51,9 @@ public class MixinMinecraft {
@Shadow
public ClientLevel level;
+ @Unique
+ private BiFunction tickProvider;
+
@Inject(
method = "",
at = @At("RETURN")
@@ -57,30 +62,68 @@ public class MixinMinecraft {
BaritoneAPI.getProvider().getPrimaryBaritone();
}
+ @Inject(
+ method = "tick",
+ at = @At(
+ value = "FIELD",
+ opcode = Opcodes.GETFIELD,
+ target = "net/minecraft/client/Minecraft.screen:Lnet/minecraft/client/gui/screens/Screen;",
+ ordinal = 0,
+ shift = At.Shift.BEFORE
+ ),
+ slice = @Slice(
+ from = @At(
+ value = "FIELD",
+ opcode = Opcodes.PUTFIELD,
+ target = "net/minecraft/client/Minecraft.missTime:I"
+ )
+ )
+ )
+ private void runTick(CallbackInfo ci) {
+ this.tickProvider = TickEvent.createNextProvider();
+
+ for (IBaritone baritone : BaritoneAPI.getProvider().getAllBaritones()) {
+ TickEvent.Type type = baritone.getPlayerContext().player() != null && baritone.getPlayerContext().world() != null
+ ? TickEvent.Type.IN
+ : TickEvent.Type.OUT;
+ baritone.getGameEventHandler().onTick(this.tickProvider.apply(EventState.PRE, type));
+ }
+ }
+
+ @Inject(
+ method = "tick",
+ at = @At("RETURN")
+ )
+ private void postRunTick(CallbackInfo ci) {
+ if (this.tickProvider == null) {
+ return;
+ }
+
+ for (IBaritone baritone : BaritoneAPI.getProvider().getAllBaritones()) {
+ TickEvent.Type type = baritone.getPlayerContext().player() != null && baritone.getPlayerContext().world() != null
+ ? TickEvent.Type.IN
+ : TickEvent.Type.OUT;
+ baritone.getGameEventHandler().onPostTick(this.tickProvider.apply(EventState.POST, type));
+ }
+
+ this.tickProvider = null;
+ }
@Inject(
method = "tick",
at = @At(
- value = "FIELD",
- opcode = Opcodes.GETFIELD,
- target = "Lnet/minecraft/client/Minecraft;screen:Lnet/minecraft/client/gui/screens/Screen;",
- ordinal = 4,
- shift = At.Shift.BY,
- by = -3
+ value = "INVOKE",
+ target = "net/minecraft/client/multiplayer/ClientLevel.tickEntities()V",
+ shift = At.Shift.AFTER
)
)
- private void runTick(CallbackInfo ci) {
- final BiFunction tickProvider = TickEvent.createNextProvider();
-
- for (IBaritone baritone : BaritoneAPI.getProvider().getAllBaritones()) {
-
- TickEvent.Type type = baritone.getPlayerContext().player() != null && baritone.getPlayerContext().world() != null
- ? TickEvent.Type.IN
- : TickEvent.Type.OUT;
-
- baritone.getGameEventHandler().onTick(tickProvider.apply(EventState.PRE, type));
+ private void postUpdateEntities(CallbackInfo ci) {
+ IBaritone baritone = BaritoneAPI.getProvider().getBaritoneForPlayer(this.player);
+ if (baritone != null) {
+ // Intentionally call this after all entities have been updated. That way, any modification to rotations
+ // can be recognized by other entity code. (Fireworks and Pigs, for example)
+ baritone.getGameEventHandler().onPlayerUpdate(new PlayerUpdateEvent(EventState.POST));
}
-
}
@Inject(
diff --git a/src/launch/java/baritone/launch/mixins/MixinPalettedContainer$Data.java b/src/launch/java/baritone/launch/mixins/MixinPalettedContainer$Data.java
new file mode 100644
index 000000000..e4c3cc61d
--- /dev/null
+++ b/src/launch/java/baritone/launch/mixins/MixinPalettedContainer$Data.java
@@ -0,0 +1,34 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.launch.mixins;
+
+import baritone.utils.accessor.IPalettedContainer.IData;
+import net.minecraft.util.BitStorage;
+import net.minecraft.world.level.chunk.Palette;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(targets = "net/minecraft/world/level/chunk/PalettedContainer$Data")
+public abstract class MixinPalettedContainer$Data implements IData {
+
+ @Accessor
+ public abstract Palette getPalette();
+
+ @Accessor
+ public abstract BitStorage getStorage();
+}
diff --git a/src/launch/java/baritone/launch/mixins/MixinPalettedContainer.java b/src/launch/java/baritone/launch/mixins/MixinPalettedContainer.java
new file mode 100644
index 000000000..a1b409a09
--- /dev/null
+++ b/src/launch/java/baritone/launch/mixins/MixinPalettedContainer.java
@@ -0,0 +1,100 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.launch.mixins;
+
+import baritone.utils.accessor.IPalettedContainer;
+import baritone.utils.accessor.IPalettedContainer.IData;
+import net.minecraft.util.BitStorage;
+import net.minecraft.world.level.chunk.Palette;
+import net.minecraft.world.level.chunk.PalettedContainer;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Unique;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+
+@Mixin(PalettedContainer.class)
+public abstract class MixinPalettedContainer implements IPalettedContainer {
+
+ private static final MethodHandle DATA_GETTER;
+
+ // Mixin has no way of referring to the data field and we can't use inheritance
+ // tricks to determine its name, so we use this ugly workaround instead.
+ // Classloading is hell here and causes accessor mixins (@Mixin interfaces with
+ // only @Accessor and @Invoker methods) to break on use and proguard hates method
+ // handles and on top of that mojang decided that error messages during world
+ // load are not needed so if you want to debug this you'll probably need an extra
+ // mixin just to display the error and hard quit the game before follow up errors
+ // blow up your log file.
+ // Mumphrey, please add the shadow classes you promised 5 years ago.
+ static {
+ Field dataField = null;
+ for (Field field : PalettedContainer.class.getDeclaredFields()) {
+ Class fieldType = field.getType();
+ if (IData.class.isAssignableFrom(fieldType)) {
+ if ((field.getModifiers() & (Modifier.STATIC | Modifier.FINAL)) != 0 || field.isSynthetic()) {
+ continue;
+ }
+ if (dataField != null) {
+ throw new IllegalStateException("PalettedContainer has more than one Data field.");
+ }
+ dataField = field;
+ }
+ }
+ if (dataField == null) {
+ throw new IllegalStateException("PalettedContainer has no Data field.");
+ }
+ MethodHandle rawGetter;
+ try {
+ rawGetter = MethodHandles.lookup().unreflectGetter(dataField);
+ } catch (IllegalAccessException impossible) {
+ // we literally are the owning class, wtf?
+ throw new IllegalStateException("PalettedContainer may not access its own field?!", impossible);
+ }
+ MethodType getterType = MethodType.methodType(IData.class, PalettedContainer.class);
+ DATA_GETTER = MethodHandles.explicitCastArguments(rawGetter, getterType);
+ }
+
+ @Override
+ public Palette getPalette() {
+ return data().getPalette();
+ }
+
+ @Override
+ public BitStorage getStorage() {
+ return data().getStorage();
+ }
+
+ @Unique
+ private IData data() {
+ try {
+ // cast to Object first so the method handle doesn't hide the interface usage from proguard
+ return (IData) (Object) DATA_GETTER.invoke((PalettedContainer) (Object) this);
+ } catch (Throwable t) {
+ throw sneaky(t, RuntimeException.class);
+ }
+ }
+
+ @Unique
+ private static T sneaky(Throwable t, Class as) throws T {
+ throw (T) t;
+ }
+}
diff --git a/src/launch/resources/mixins.baritone.json b/src/launch/resources/mixins.baritone.json
index 4b9ea4c91..35d5ae0d6 100644
--- a/src/launch/resources/mixins.baritone.json
+++ b/src/launch/resources/mixins.baritone.json
@@ -15,13 +15,16 @@
"MixinCommandSuggestionHelper",
"MixinEntity",
"MixinEntityRenderManager",
+ "MixinFireworkRocketEntity",
"MixinItemStack",
"MixinLivingEntity",
"MixinLootContext",
"MixinMinecraft",
"MixinNetworkManager",
+ "MixinPalettedContainer",
+ "MixinPalettedContainer$Data",
"MixinPlayerController",
"MixinScreen",
"MixinWorldRenderer"
]
-}
\ No newline at end of file
+}
diff --git a/src/main/java/baritone/Baritone.java b/src/main/java/baritone/Baritone.java
index 7174a1228..c1176a3d4 100755
--- a/src/main/java/baritone/Baritone.java
+++ b/src/main/java/baritone/Baritone.java
@@ -20,8 +20,10 @@ package baritone;
import baritone.api.BaritoneAPI;
import baritone.api.IBaritone;
import baritone.api.Settings;
+import baritone.api.behavior.IBehavior;
import baritone.api.event.listener.IEventBus;
-import baritone.api.utils.Helper;
+import baritone.api.process.IBaritoneProcess;
+import baritone.api.process.IElytraProcess;
import baritone.api.utils.IPlayerContext;
import baritone.behavior.*;
import baritone.cache.WorldProvider;
@@ -33,16 +35,19 @@ import baritone.utils.BlockStateInterface;
import baritone.utils.GuiClick;
import baritone.utils.InputOverrideHandler;
import baritone.utils.PathingControlManager;
-import baritone.utils.player.PrimaryPlayerContext;
+import baritone.utils.player.BaritonePlayerContext;
import net.minecraft.client.Minecraft;
-import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
import java.util.concurrent.Executor;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
/**
* @author Brady
@@ -50,87 +55,103 @@ import java.util.concurrent.TimeUnit;
*/
public class Baritone implements IBaritone {
- private static ThreadPoolExecutor threadPool;
- private static File dir;
+ private static final ThreadPoolExecutor threadPool;
static {
threadPool = new ThreadPoolExecutor(4, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<>());
-
- dir = new File(Minecraft.getInstance().gameDirectory, "baritone");
- if (!Files.exists(dir.toPath())) {
- try {
- Files.createDirectories(dir.toPath());
- } catch (IOException ignored) {}
- }
}
- private GameEventHandler gameEventHandler;
+ private final Minecraft mc;
+ private final Path directory;
- private PathingBehavior pathingBehavior;
- private LookBehavior lookBehavior;
- private InventoryBehavior inventoryBehavior;
- private WaypointBehavior waypointBehavior;
- private InputOverrideHandler inputOverrideHandler;
+ private final GameEventHandler gameEventHandler;
- private FollowProcess followProcess;
- private MineProcess mineProcess;
- private GetToBlockProcess getToBlockProcess;
- private CustomGoalProcess customGoalProcess;
- private BuilderProcess builderProcess;
- private ExploreProcess exploreProcess;
- private BackfillProcess backfillProcess;
- private FarmProcess farmProcess;
+ private final PathingBehavior pathingBehavior;
+ private final LookBehavior lookBehavior;
+ private final InventoryBehavior inventoryBehavior;
+ private final InputOverrideHandler inputOverrideHandler;
- private PathingControlManager pathingControlManager;
- private SelectionManager selectionManager;
- private CommandManager commandManager;
+ private final FollowProcess followProcess;
+ private final MineProcess mineProcess;
+ private final GetToBlockProcess getToBlockProcess;
+ private final CustomGoalProcess customGoalProcess;
+ private final BuilderProcess builderProcess;
+ private final ExploreProcess exploreProcess;
+ private final FarmProcess farmProcess;
+ private final InventoryPauserProcess inventoryPauserProcess;
+ private final ElytraProcess elytraProcess;
- private IPlayerContext playerContext;
- private WorldProvider worldProvider;
+ private final PathingControlManager pathingControlManager;
+ private final SelectionManager selectionManager;
+ private final CommandManager commandManager;
+
+ private final IPlayerContext playerContext;
+ private final WorldProvider worldProvider;
public BlockStateInterface bsi;
- Baritone() {
+ Baritone(Minecraft mc) {
+ this.mc = mc;
this.gameEventHandler = new GameEventHandler(this);
+ this.directory = mc.gameDirectory.toPath().resolve("baritone");
+ if (!Files.exists(this.directory)) {
+ try {
+ Files.createDirectories(this.directory);
+ } catch (IOException ignored) {}
+ }
+
// Define this before behaviors try and get it, or else it will be null and the builds will fail!
- this.playerContext = PrimaryPlayerContext.INSTANCE;
+ this.playerContext = new BaritonePlayerContext(this, mc);
{
- // the Behavior constructor calls baritone.registerBehavior(this) so this populates the behaviors arraylist
- pathingBehavior = new PathingBehavior(this);
- lookBehavior = new LookBehavior(this);
- inventoryBehavior = new InventoryBehavior(this);
- inputOverrideHandler = new InputOverrideHandler(this);
- waypointBehavior = new WaypointBehavior(this);
+ this.lookBehavior = this.registerBehavior(LookBehavior::new);
+ this.pathingBehavior = this.registerBehavior(PathingBehavior::new);
+ this.inventoryBehavior = this.registerBehavior(InventoryBehavior::new);
+ this.inputOverrideHandler = this.registerBehavior(InputOverrideHandler::new);
+ this.registerBehavior(WaypointBehavior::new);
}
this.pathingControlManager = new PathingControlManager(this);
{
- this.pathingControlManager.registerProcess(followProcess = new FollowProcess(this));
- this.pathingControlManager.registerProcess(mineProcess = new MineProcess(this));
- this.pathingControlManager.registerProcess(customGoalProcess = new CustomGoalProcess(this)); // very high iq
- this.pathingControlManager.registerProcess(getToBlockProcess = new GetToBlockProcess(this));
- this.pathingControlManager.registerProcess(builderProcess = new BuilderProcess(this));
- this.pathingControlManager.registerProcess(exploreProcess = new ExploreProcess(this));
- this.pathingControlManager.registerProcess(backfillProcess = new BackfillProcess(this));
- this.pathingControlManager.registerProcess(farmProcess = new FarmProcess(this));
+ this.followProcess = this.registerProcess(FollowProcess::new);
+ this.mineProcess = this.registerProcess(MineProcess::new);
+ this.customGoalProcess = this.registerProcess(CustomGoalProcess::new); // very high iq
+ this.getToBlockProcess = this.registerProcess(GetToBlockProcess::new);
+ this.builderProcess = this.registerProcess(BuilderProcess::new);
+ this.exploreProcess = this.registerProcess(ExploreProcess::new);
+ this.farmProcess = this.registerProcess(FarmProcess::new);
+ this.inventoryPauserProcess = this.registerProcess(InventoryPauserProcess::new);
+ this.elytraProcess = this.registerProcess(ElytraProcess::create);
+ this.registerProcess(BackfillProcess::new);
}
- this.worldProvider = new WorldProvider();
+ this.worldProvider = new WorldProvider(this);
this.selectionManager = new SelectionManager(this);
this.commandManager = new CommandManager(this);
}
+ public void registerBehavior(IBehavior behavior) {
+ this.gameEventHandler.registerEventListener(behavior);
+ }
+
+ public T registerBehavior(Function constructor) {
+ final T behavior = constructor.apply(this);
+ this.registerBehavior(behavior);
+ return behavior;
+ }
+
+ public T registerProcess(Function constructor) {
+ final T behavior = constructor.apply(this);
+ this.pathingControlManager.registerProcess(behavior);
+ return behavior;
+ }
+
@Override
public PathingControlManager getPathingControlManager() {
return this.pathingControlManager;
}
- public void registerBehavior(Behavior behavior) {
- this.gameEventHandler.registerEventListener(behavior);
- }
-
@Override
public InputOverrideHandler getInputOverrideHandler() {
return this.inputOverrideHandler;
@@ -170,6 +191,7 @@ public class Baritone implements IBaritone {
return this.lookBehavior;
}
+ @Override
public ExploreProcess getExploreProcess() {
return this.exploreProcess;
}
@@ -179,10 +201,15 @@ public class Baritone implements IBaritone {
return this.mineProcess;
}
+ @Override
public FarmProcess getFarmProcess() {
return this.farmProcess;
}
+ public InventoryPauserProcess getInventoryPauserProcess() {
+ return this.inventoryPauserProcess;
+ }
+
@Override
public PathingBehavior getPathingBehavior() {
return this.pathingBehavior;
@@ -208,24 +235,29 @@ public class Baritone implements IBaritone {
return this.commandManager;
}
+ @Override
+ public IElytraProcess getElytraProcess() {
+ return this.elytraProcess;
+ }
+
@Override
public void openClick() {
new Thread(() -> {
try {
Thread.sleep(100);
- Helper.mc.execute(() -> Helper.mc.setScreen(new GuiClick()));
+ mc.execute(() -> mc.setScreen(new GuiClick()));
} catch (Exception ignored) {}
}).start();
}
+ public Path getDirectory() {
+ return this.directory;
+ }
+
public static Settings settings() {
return BaritoneAPI.getSettings();
}
- public static File getDir() {
- return dir;
- }
-
public static Executor getExecutor() {
return threadPool;
}
diff --git a/src/main/java/baritone/BaritoneProvider.java b/src/main/java/baritone/BaritoneProvider.java
index d5457cf85..f34d9bcb9 100644
--- a/src/main/java/baritone/BaritoneProvider.java
+++ b/src/main/java/baritone/BaritoneProvider.java
@@ -22,13 +22,15 @@ import baritone.api.IBaritoneProvider;
import baritone.api.cache.IWorldScanner;
import baritone.api.command.ICommandSystem;
import baritone.api.schematic.ISchematicSystem;
-import baritone.cache.WorldScanner;
+import baritone.cache.FasterWorldScanner;
import baritone.command.CommandSystem;
import baritone.command.ExampleBaritoneControl;
import baritone.utils.schematic.SchematicSystem;
+import net.minecraft.client.Minecraft;
import java.util.Collections;
import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
/**
* @author Brady
@@ -36,30 +38,45 @@ import java.util.List;
*/
public final class BaritoneProvider implements IBaritoneProvider {
- private final Baritone primary;
private final List all;
+ private final List allView;
- {
- this.primary = new Baritone();
- this.all = Collections.singletonList(this.primary);
+ public BaritoneProvider() {
+ this.all = new CopyOnWriteArrayList<>();
+ this.allView = Collections.unmodifiableList(this.all);
// Setup chat control, just for the primary instance
- new ExampleBaritoneControl(this.primary);
+ final Baritone primary = (Baritone) this.createBaritone(Minecraft.getInstance());
+ primary.registerBehavior(ExampleBaritoneControl::new);
}
@Override
public IBaritone getPrimaryBaritone() {
- return primary;
+ return this.all.get(0);
}
@Override
public List getAllBaritones() {
- return all;
+ return this.allView;
+ }
+
+ @Override
+ public synchronized IBaritone createBaritone(Minecraft minecraft) {
+ IBaritone baritone = this.getBaritoneForMinecraft(minecraft);
+ if (baritone == null) {
+ this.all.add(baritone = new Baritone(minecraft));
+ }
+ return baritone;
+ }
+
+ @Override
+ public synchronized boolean destroyBaritone(IBaritone baritone) {
+ return baritone != this.getPrimaryBaritone() && this.all.remove(baritone);
}
@Override
public IWorldScanner getWorldScanner() {
- return WorldScanner.INSTANCE;
+ return FasterWorldScanner.INSTANCE;
}
@Override
diff --git a/src/main/java/baritone/behavior/Behavior.java b/src/main/java/baritone/behavior/Behavior.java
index 36273c026..848beb298 100644
--- a/src/main/java/baritone/behavior/Behavior.java
+++ b/src/main/java/baritone/behavior/Behavior.java
@@ -35,6 +35,5 @@ public class Behavior implements IBehavior {
protected Behavior(Baritone baritone) {
this.baritone = baritone;
this.ctx = baritone.getPlayerContext();
- baritone.registerBehavior(this);
}
}
diff --git a/src/main/java/baritone/behavior/InventoryBehavior.java b/src/main/java/baritone/behavior/InventoryBehavior.java
index 570a3e1c8..43a553d4d 100644
--- a/src/main/java/baritone/behavior/InventoryBehavior.java
+++ b/src/main/java/baritone/behavior/InventoryBehavior.java
@@ -19,6 +19,7 @@ package baritone.behavior;
import baritone.Baritone;
import baritone.api.event.events.TickEvent;
+import baritone.api.utils.Helper;
import baritone.utils.ToolSet;
import net.minecraft.client.player.LocalPlayer;
import net.minecraft.core.Direction;
@@ -42,7 +43,10 @@ import java.util.OptionalInt;
import java.util.Random;
import java.util.function.Predicate;
-public final class InventoryBehavior extends Behavior {
+public final class InventoryBehavior extends Behavior implements Helper {
+
+ int ticksSinceLastInventoryMove;
+ int[] lastTickRequestedMove; // not everything asks every tick, so remember the request while coming to a halt
public InventoryBehavior(Baritone baritone) {
super(baritone);
@@ -60,20 +64,28 @@ public final class InventoryBehavior extends Behavior {
// we have a crafting table or a chest or something open
return;
}
+ ticksSinceLastInventoryMove++;
if (firstValidThrowaway() >= 9) { // aka there are none on the hotbar, but there are some in main inventory
- swapWithHotBar(firstValidThrowaway(), 8);
+ requestSwapWithHotBar(firstValidThrowaway(), 8);
}
int pick = bestToolAgainst(Blocks.STONE, PickaxeItem.class);
if (pick >= 9) {
- swapWithHotBar(pick, 0);
+ requestSwapWithHotBar(pick, 0);
+ }
+ if (lastTickRequestedMove != null) {
+ logDebug("Remembering to move " + lastTickRequestedMove[0] + " " + lastTickRequestedMove[1] + " from a previous tick");
+ requestSwapWithHotBar(lastTickRequestedMove[0], lastTickRequestedMove[1]);
}
}
- public void attemptToPutOnHotbar(int inMainInvy, Predicate disallowedHotbar) {
+ public boolean attemptToPutOnHotbar(int inMainInvy, Predicate disallowedHotbar) {
OptionalInt destination = getTempHotbarSlot(disallowedHotbar);
if (destination.isPresent()) {
- swapWithHotBar(inMainInvy, destination.getAsInt());
+ if (!requestSwapWithHotBar(inMainInvy, destination.getAsInt())) {
+ return false;
+ }
}
+ return true;
}
public OptionalInt getTempHotbarSlot(Predicate disallowedHotbar) {
@@ -97,8 +109,20 @@ public final class InventoryBehavior extends Behavior {
return OptionalInt.of(candidates.get(new Random().nextInt(candidates.size())));
}
- private void swapWithHotBar(int inInventory, int inHotbar) {
+ private boolean requestSwapWithHotBar(int inInventory, int inHotbar) {
+ lastTickRequestedMove = new int[]{inInventory, inHotbar};
+ if (ticksSinceLastInventoryMove < Baritone.settings().ticksBetweenInventoryMoves.value) {
+ logDebug("Inventory move requested but delaying " + ticksSinceLastInventoryMove + " " + Baritone.settings().ticksBetweenInventoryMoves.value);
+ return false;
+ }
+ if (Baritone.settings().inventoryMoveOnlyIfStationary.value && !baritone.getInventoryPauserProcess().stationaryForInventoryMove()) {
+ logDebug("Inventory move requested but delaying until stationary");
+ return false;
+ }
ctx.playerController().windowClick(ctx.player().inventoryMenu.containerId, inInventory < 9 ? inInventory + 36 : inInventory, inHotbar, ClickType.SWAP, ctx.player());
+ ticksSinceLastInventoryMove = 0;
+ lastTickRequestedMove = null;
+ return true;
}
private int firstValidThrowaway() { // TODO offhand idk
@@ -200,8 +224,8 @@ public final class InventoryBehavior extends Behavior {
if (allowInventory) {
for (int i = 9; i < 36; i++) {
if (desired.test(inv.get(i))) {
- swapWithHotBar(i, 7);
if (select) {
+ requestSwapWithHotBar(i, 7);
p.getInventory().selected = 7;
}
return true;
diff --git a/src/main/java/baritone/behavior/LookBehavior.java b/src/main/java/baritone/behavior/LookBehavior.java
index e9b0ca661..e694a8ee0 100644
--- a/src/main/java/baritone/behavior/LookBehavior.java
+++ b/src/main/java/baritone/behavior/LookBehavior.java
@@ -20,80 +20,113 @@ package baritone.behavior;
import baritone.Baritone;
import baritone.api.Settings;
import baritone.api.behavior.ILookBehavior;
-import baritone.api.event.events.PlayerUpdateEvent;
-import baritone.api.event.events.RotationMoveEvent;
+import baritone.api.behavior.look.IAimProcessor;
+import baritone.api.behavior.look.ITickableAimProcessor;
+import baritone.api.event.events.*;
+import baritone.api.utils.IPlayerContext;
import baritone.api.utils.Rotation;
+import baritone.behavior.look.ForkableRandom;
+import net.minecraft.network.protocol.game.ServerboundMovePlayerPacket;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.Optional;
public final class LookBehavior extends Behavior implements ILookBehavior {
/**
- * Target's values are as follows:
+ * The current look target, may be {@code null}.
*/
- private Rotation target;
+ private Target target;
/**
- * Whether or not rotations are currently being forced
+ * The rotation known to the server. Returned by {@link #getEffectiveRotation()} for use in {@link IPlayerContext}.
*/
- private boolean force;
+ private Rotation serverRotation;
/**
- * The last player yaw angle. Used when free looking
+ * The last player rotation. Used to restore the player's angle when using free look.
*
* @see Settings#freeLook
*/
- private float lastYaw;
+ private Rotation prevRotation;
+
+ private final AimProcessor processor;
+
+ private final Deque smoothYawBuffer;
+ private final Deque smoothPitchBuffer;
public LookBehavior(Baritone baritone) {
super(baritone);
+ this.processor = new AimProcessor(baritone.getPlayerContext());
+ this.smoothYawBuffer = new ArrayDeque<>();
+ this.smoothPitchBuffer = new ArrayDeque<>();
}
@Override
- public void updateTarget(Rotation target, boolean force) {
- this.target = target;
- if (!force) {
- double rand = Math.random() - 0.5;
- if (Math.abs(rand) < 0.1) {
- rand *= 4;
- }
- this.target = new Rotation(this.target.getYaw() + (float) (rand * Baritone.settings().randomLooking113.value), this.target.getPitch());
+ public void updateTarget(Rotation rotation, boolean blockInteract) {
+ this.target = new Target(rotation, Target.Mode.resolve(ctx, blockInteract));
+ }
+
+ @Override
+ public IAimProcessor getAimProcessor() {
+ return this.processor;
+ }
+
+ @Override
+ public void onTick(TickEvent event) {
+ if (event.getType() == TickEvent.Type.IN) {
+ this.processor.tick();
}
- this.force = force || !Baritone.settings().freeLook.value;
}
@Override
public void onPlayerUpdate(PlayerUpdateEvent event) {
+ System.out.println(event.getState() + " " + ctx.player().getXRot() + " " + ctx.player().getYRot() + " " + ctx.player().xRotO + " " + ctx.player().yRotO);
+
if (this.target == null) {
return;
}
- // Whether or not we're going to silently set our angles
- boolean silent = Baritone.settings().antiCheatCompatibility.value && !this.force;
-
switch (event.getState()) {
case PRE: {
- if (this.force) {
- ctx.player().setYRot(this.target.getYaw());
- float oldPitch = ctx.player().getXRot();
- float desiredPitch = this.target.getPitch();
- ctx.player().setXRot(desiredPitch);
- ctx.player().setYRot((float) (ctx.player().getYRot() + (Math.random() - 0.5) * Baritone.settings().randomLooking.value));
- ctx.player().setXRot((float) (ctx.player().getXRot() + (Math.random() - 0.5) * Baritone.settings().randomLooking.value));
- if (desiredPitch == oldPitch && !Baritone.settings().freeLook.value) {
- nudgeToLevel();
- }
- this.target = null;
- }
- if (silent) {
- this.lastYaw = ctx.player().getYRot();
- ctx.player().setYRot(this.target.getYaw());
+ if (this.target.mode == Target.Mode.NONE) {
+ // Just return for PRE, we still want to set target to null on POST
+ return;
}
+
+ this.prevRotation = new Rotation(ctx.player().getYRot(), ctx.player().getXRot());
+ final Rotation actual = this.processor.peekRotation(this.target.rotation);
+ ctx.player().setYRot(actual.getYaw());
+ ctx.player().setXRot(actual.getPitch());
break;
}
case POST: {
- if (silent) {
- ctx.player().setYRot(this.lastYaw);
- this.target = null;
+ // Reset the player's rotations back to their original values
+ if (this.prevRotation != null) {
+ this.smoothYawBuffer.addLast(this.target.rotation.getYaw());
+ while (this.smoothYawBuffer.size() > Baritone.settings().smoothLookTicks.value) {
+ this.smoothYawBuffer.removeFirst();
+ }
+ this.smoothPitchBuffer.addLast(this.target.rotation.getPitch());
+ while (this.smoothPitchBuffer.size() > Baritone.settings().smoothLookTicks.value) {
+ this.smoothPitchBuffer.removeFirst();
+ }
+ if (this.target.mode == Target.Mode.SERVER) {
+ ctx.player().setYRot(this.prevRotation.getYaw());
+ ctx.player().setXRot(this.prevRotation.getPitch());
+ } else if (ctx.player().isFallFlying() ? Baritone.settings().elytraSmoothLook.value : Baritone.settings().smoothLook.value) {
+ ctx.player().setYRot((float) this.smoothYawBuffer.stream().mapToDouble(d -> d).average().orElse(this.prevRotation.getYaw()));
+ if (ctx.player().isFallFlying()) {
+ ctx.player().setXRot((float) this.smoothPitchBuffer.stream().mapToDouble(d -> d).average().orElse(this.prevRotation.getPitch()));
+ }
+ }
+ //ctx.player().xRotO = prevRotation.getPitch();
+ //ctx.player().yRotO = prevRotation.getYaw();
+ this.prevRotation = null;
}
+ // The target is done being used for this game tick, so it can be invalidated
+ this.target = null;
break;
}
default:
@@ -101,34 +134,227 @@ public final class LookBehavior extends Behavior implements ILookBehavior {
}
}
+ @Override
+ public void onSendPacket(PacketEvent event) {
+ if (!(event.getPacket() instanceof ServerboundMovePlayerPacket)) {
+ return;
+ }
+
+ final ServerboundMovePlayerPacket packet = (ServerboundMovePlayerPacket) event.getPacket();
+ if (packet instanceof ServerboundMovePlayerPacket.Rot || packet instanceof ServerboundMovePlayerPacket.PosRot) {
+ this.serverRotation = new Rotation(packet.getYRot(0.0f), packet.getXRot(0.0f));
+ }
+ }
+
+ @Override
+ public void onWorldEvent(WorldEvent event) {
+ this.serverRotation = null;
+ this.target = null;
+ }
+
public void pig() {
if (this.target != null) {
- ctx.player().setYRot(this.target.getYaw());
+ final Rotation actual = this.processor.peekRotation(this.target.rotation);
+ ctx.player().setYRot(actual.getYaw());
}
}
+ public Optional getEffectiveRotation() {
+ if (Baritone.settings().freeLook.value) {
+ return Optional.ofNullable(this.serverRotation);
+ }
+ // If freeLook isn't on, just defer to the player's actual rotations
+ return Optional.empty();
+ }
+
@Override
public void onPlayerRotationMove(RotationMoveEvent event) {
if (this.target != null) {
+ final Rotation actual = this.processor.peekRotation(this.target.rotation);
+ event.setYaw(actual.getYaw());
+ event.setPitch(actual.getPitch());
+ }
+ }
- event.setYaw(this.target.getYaw());
+ private static final class AimProcessor extends AbstractAimProcessor {
- // If we have antiCheatCompatibility on, we're going to use the target value later in onPlayerUpdate()
- // Also the type has to be MOTION_UPDATE because that is called after JUMP
- if (!Baritone.settings().antiCheatCompatibility.value && event.getType() == RotationMoveEvent.Type.MOTION_UPDATE && !this.force) {
- this.target = null;
+ public AimProcessor(final IPlayerContext ctx) {
+ super(ctx);
+ }
+
+ @Override
+ protected Rotation getPrevRotation() {
+ // Implementation will use LookBehavior.serverRotation
+ return ctx.playerRotations();
+ }
+ }
+
+ private static abstract class AbstractAimProcessor implements ITickableAimProcessor {
+
+ protected final IPlayerContext ctx;
+ private final ForkableRandom rand;
+ private double randomYawOffset;
+ private double randomPitchOffset;
+
+ public AbstractAimProcessor(IPlayerContext ctx) {
+ this.ctx = ctx;
+ this.rand = new ForkableRandom();
+ }
+
+ private AbstractAimProcessor(final AbstractAimProcessor source) {
+ this.ctx = source.ctx;
+ this.rand = source.rand.fork();
+ this.randomYawOffset = source.randomYawOffset;
+ this.randomPitchOffset = source.randomPitchOffset;
+ }
+
+ @Override
+ public final Rotation peekRotation(final Rotation rotation) {
+ final Rotation prev = this.getPrevRotation();
+
+ float desiredYaw = rotation.getYaw();
+ float desiredPitch = rotation.getPitch();
+
+ // In other words, the target doesn't care about the pitch, so it used playerRotations().getPitch()
+ // and it's safe to adjust it to a normal level
+ if (desiredPitch == prev.getPitch()) {
+ desiredPitch = nudgeToLevel(desiredPitch);
+ }
+
+ desiredYaw += this.randomYawOffset;
+ desiredPitch += this.randomPitchOffset;
+
+ return new Rotation(
+ this.calculateMouseMove(prev.getYaw(), desiredYaw),
+ this.calculateMouseMove(prev.getPitch(), desiredPitch)
+ ).clamp();
+ }
+
+ @Override
+ public final void tick() {
+ // randomLooking
+ this.randomYawOffset = (this.rand.nextDouble() - 0.5) * Baritone.settings().randomLooking.value;
+ this.randomPitchOffset = (this.rand.nextDouble() - 0.5) * Baritone.settings().randomLooking.value;
+
+ // randomLooking113
+ double random = this.rand.nextDouble() - 0.5;
+ if (Math.abs(random) < 0.1) {
+ random *= 4;
+ }
+ this.randomYawOffset += random * Baritone.settings().randomLooking113.value;
+ }
+
+ @Override
+ public final void advance(int ticks) {
+ for (int i = 0; i < ticks; i++) {
+ this.tick();
+ }
+ }
+
+ @Override
+ public Rotation nextRotation(final Rotation rotation) {
+ final Rotation actual = this.peekRotation(rotation);
+ this.tick();
+ return actual;
+ }
+
+ @Override
+ public final ITickableAimProcessor fork() {
+ return new AbstractAimProcessor(this) {
+
+ private Rotation prev = AbstractAimProcessor.this.getPrevRotation();
+
+ @Override
+ public Rotation nextRotation(final Rotation rotation) {
+ return (this.prev = super.nextRotation(rotation));
+ }
+
+ @Override
+ protected Rotation getPrevRotation() {
+ return this.prev;
+ }
+ };
+ }
+
+ protected abstract Rotation getPrevRotation();
+
+ /**
+ * Nudges the player's pitch to a regular level. (Between {@code -20} and {@code 10}, increments are by {@code 1})
+ */
+ private float nudgeToLevel(float pitch) {
+ if (pitch < -20) {
+ return pitch + 1;
+ } else if (pitch > 10) {
+ return pitch - 1;
+ }
+ return pitch;
+ }
+
+ private float calculateMouseMove(float current, float target) {
+ final float delta = target - current;
+ final double deltaPx = angleToMouse(delta); // yes, even the mouse movements use double
+ return current + mouseToAngle(deltaPx);
+ }
+
+ private double angleToMouse(float angleDelta) {
+ final float minAngleChange = mouseToAngle(1);
+ return Math.round(angleDelta / minAngleChange);
+ }
+
+ private float mouseToAngle(double mouseDelta) {
+ // casting float literals to double gets us the precise values used by mc
+ final double f = ctx.minecraft().options.sensitivity().get() * (double) 0.6f + (double) 0.2f;
+ return (float) (mouseDelta * f * f * f * 8.0d) * 0.15f; // yes, one double and one float scaling factor
+ }
+ }
+
+ private static class Target {
+
+ public final Rotation rotation;
+ public final Mode mode;
+
+ public Target(Rotation rotation, Mode mode) {
+ this.rotation = rotation;
+ this.mode = mode;
+ }
+
+ enum Mode {
+ /**
+ * Rotation will be set client-side and is visual to the player
+ */
+ CLIENT,
+
+ /**
+ * Rotation will be set server-side and is silent to the player
+ */
+ SERVER,
+
+ /**
+ * Rotation will remain unaffected on both the client and server
+ */
+ NONE;
+
+ static Mode resolve(IPlayerContext ctx, boolean blockInteract) {
+ final Settings settings = Baritone.settings();
+ final boolean antiCheat = settings.antiCheatCompatibility.value;
+ final boolean blockFreeLook = settings.blockFreeLook.value;
+
+ if (ctx.player().isFallFlying()) {
+ // always need to set angles while flying
+ return settings.elytraFreeLook.value ? SERVER : CLIENT;
+ } else if (settings.freeLook.value) {
+ // Regardless of if antiCheatCompatibility is enabled, if a blockInteract is requested then the player
+ // rotation needs to be set somehow, otherwise Baritone will halt since objectMouseOver() will just be
+ // whatever the player is mousing over visually. Let's just settle for setting it silently.
+ if (blockInteract) {
+ return blockFreeLook ? SERVER : CLIENT;
+ }
+ return antiCheat ? SERVER : NONE;
+ }
+
+ // all freeLook settings are disabled so set the angles
+ return CLIENT;
}
}
}
-
- /**
- * Nudges the player's pitch to a regular level. (Between {@code -20} and {@code 10}, increments are by {@code 1})
- */
- private void nudgeToLevel() {
- if (ctx.player().getXRot() < -20) {
- ctx.player().setXRot(ctx.player().getXRot() + 1);
- } else if (ctx.player().getXRot() > 10) {
- ctx.player().setXRot(ctx.player().getXRot() - 1);
- }
- }
}
diff --git a/src/main/java/baritone/behavior/PathingBehavior.java b/src/main/java/baritone/behavior/PathingBehavior.java
index 9a8c4d1b5..b7c035598 100644
--- a/src/main/java/baritone/behavior/PathingBehavior.java
+++ b/src/main/java/baritone/behavior/PathingBehavior.java
@@ -33,6 +33,7 @@ import baritone.pathing.calc.AbstractNodeCostSearch;
import baritone.pathing.movement.CalculationContext;
import baritone.pathing.movement.MovementHelper;
import baritone.pathing.path.PathExecutor;
+import baritone.process.ElytraProcess;
import baritone.utils.PathRenderer;
import baritone.utils.PathingCommandContext;
import baritone.utils.pathing.Favoring;
@@ -238,11 +239,11 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
if (current != null) {
switch (event.getState()) {
case PRE:
- lastAutoJump = mc.options.autoJump().get();
- mc.options.autoJump().set(false);
+ lastAutoJump = ctx.minecraft().options.autoJump().get();
+ ctx.minecraft().options.autoJump().set(false);
break;
case POST:
- mc.options.autoJump().set(lastAutoJump);
+ ctx.minecraft().options.autoJump().set(lastAutoJump);
break;
default:
break;
@@ -308,7 +309,10 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
}
public boolean isSafeToCancel() {
- return current == null || safeToCancel;
+ if (current == null) {
+ return !baritone.getElytraProcess().isActive() || baritone.getElytraProcess().isSafeToCancel();
+ }
+ return safeToCancel;
}
public void requestPause() {
@@ -351,7 +355,7 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
}
// just cancel the current path
- private void secretInternalSegmentCancel() {
+ public void secretInternalSegmentCancel() {
queuePathEvent(PathEvent.CANCELED);
synchronized (pathPlanLock) {
getInProgress().ifPresent(AbstractNodeCostSearch::cancel);
diff --git a/src/main/java/baritone/behavior/look/ForkableRandom.java b/src/main/java/baritone/behavior/look/ForkableRandom.java
new file mode 100644
index 000000000..5f5f942d2
--- /dev/null
+++ b/src/main/java/baritone/behavior/look/ForkableRandom.java
@@ -0,0 +1,85 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.behavior.look;
+
+import java.util.Arrays;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.LongSupplier;
+
+/**
+ * Implementation of Xoroshiro256++
+ *
+ * Extended to produce random double-precision floating point numbers, and allow copies to be spawned via {@link #fork},
+ * which share the same internal state as the source object.
+ *
+ * @author Brady
+ */
+public final class ForkableRandom {
+
+ private static final double DOUBLE_UNIT = 0x1.0p-53;
+
+ private final long[] s;
+
+ public ForkableRandom() {
+ this(System.nanoTime() ^ System.currentTimeMillis());
+ }
+
+ public ForkableRandom(long seedIn) {
+ final AtomicLong seed = new AtomicLong(seedIn);
+ final LongSupplier splitmix64 = () -> {
+ long z = seed.addAndGet(0x9e3779b97f4a7c15L);
+ z = (z ^ (z >>> 30)) * 0xbf58476d1ce4e5b9L;
+ z = (z ^ (z >>> 27)) * 0x94d049bb133111ebL;
+ return z ^ (z >>> 31);
+ };
+ this.s = new long[] {
+ splitmix64.getAsLong(),
+ splitmix64.getAsLong(),
+ splitmix64.getAsLong(),
+ splitmix64.getAsLong()
+ };
+ }
+
+ private ForkableRandom(long[] s) {
+ this.s = s;
+ }
+
+ public double nextDouble() {
+ return (this.next() >>> 11) * DOUBLE_UNIT;
+ }
+
+ public long next() {
+ final long result = rotl(this.s[0] + this.s[3], 23) + this.s[0];
+ final long t = this.s[1] << 17;
+ this.s[2] ^= this.s[0];
+ this.s[3] ^= this.s[1];
+ this.s[1] ^= this.s[2];
+ this.s[0] ^= this.s[3];
+ this.s[2] ^= t;
+ this.s[3] = rotl(this.s[3], 45);
+ return result;
+ }
+
+ public ForkableRandom fork() {
+ return new ForkableRandom(Arrays.copyOf(this.s, 4));
+ }
+
+ private static long rotl(long x, int k) {
+ return (x << k) | (x >>> (64 - k));
+ }
+}
diff --git a/src/main/java/baritone/cache/CachedChunk.java b/src/main/java/baritone/cache/CachedChunk.java
index bbc713af7..2659c4feb 100644
--- a/src/main/java/baritone/cache/CachedChunk.java
+++ b/src/main/java/baritone/cache/CachedChunk.java
@@ -21,16 +21,17 @@ import baritone.api.utils.BlockUtils;
import baritone.utils.pathing.PathingBlockType;
import com.google.common.collect.ImmutableSet;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
-import java.util.ArrayList;
-import java.util.BitSet;
-import java.util.List;
-import java.util.Map;
import net.minecraft.core.BlockPos;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.Blocks;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.dimension.DimensionType;
+import java.util.ArrayList;
+import java.util.BitSet;
+import java.util.List;
+import java.util.Map;
+
/**
* @author Brady
* @since 8/3/2018
@@ -217,7 +218,7 @@ public final class CachedChunk {
// nether roof is always unbreakable
return Blocks.BEDROCK.defaultBlockState();
}
- if (y < 5 && dimension.natural()) {
+ if (y < -59 && dimension.natural()) {
// solid blocks below 5 are commonly bedrock
// however, returning bedrock always would be a little yikes
// discourage paths that include breaking blocks below 5 a little more heavily just so that it takes paths breaking what's known to be stone (at 5 or above) instead of what could maybe be bedrock (below 5)
diff --git a/src/main/java/baritone/cache/CachedRegion.java b/src/main/java/baritone/cache/CachedRegion.java
index 9bcebcaad..8aa992d79 100644
--- a/src/main/java/baritone/cache/CachedRegion.java
+++ b/src/main/java/baritone/cache/CachedRegion.java
@@ -20,6 +20,10 @@ package baritone.cache;
import baritone.Baritone;
import baritone.api.cache.ICachedRegion;
import baritone.api.utils.BlockUtils;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.dimension.DimensionType;
+
import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
@@ -27,9 +31,6 @@ import java.nio.file.Paths;
import java.util.*;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;
-import net.minecraft.core.BlockPos;
-import net.minecraft.world.level.block.state.BlockState;
-import net.minecraft.world.level.dimension.DimensionType;
/**
* @author Brady
diff --git a/src/main/java/baritone/cache/CachedWorld.java b/src/main/java/baritone/cache/CachedWorld.java
index 4e323097c..e456382e6 100644
--- a/src/main/java/baritone/cache/CachedWorld.java
+++ b/src/main/java/baritone/cache/CachedWorld.java
@@ -23,22 +23,21 @@ import baritone.api.IBaritone;
import baritone.api.cache.ICachedWorld;
import baritone.api.cache.IWorldData;
import baritone.api.utils.Helper;
+import com.google.common.cache.CacheBuilder;
import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.chunk.LevelChunk;
+import net.minecraft.world.level.dimension.DimensionType;
+
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.LinkedBlockingQueue;
-import net.minecraft.core.BlockPos;
-import net.minecraft.resources.ResourceKey;
-import net.minecraft.world.level.ChunkPos;
-import net.minecraft.world.level.Level;
-import net.minecraft.world.level.chunk.LevelChunk;
-import net.minecraft.world.level.dimension.DimensionType;
/**
* @author Brady
@@ -71,7 +70,7 @@ public final class CachedWorld implements ICachedWorld, Helper {
* All chunk positions pending packing. This map will be updated in-place if a new update to the chunk occurs
* while waiting in the queue for the packer thread to get to it.
*/
- private final Map toPackMap = new ConcurrentHashMap<>();
+ private final Map toPackMap = CacheBuilder.newBuilder().softValues().build().asMap();
private final DimensionType dimension;
@@ -309,6 +308,9 @@ public final class CachedWorld implements ICachedWorld, Helper {
try {
ChunkPos pos = toPackQueue.take();
LevelChunk chunk = toPackMap.remove(pos);
+ if (toPackQueue.size() > Baritone.settings().chunkPackerQueueMaxSize.value) {
+ continue;
+ }
CachedChunk cached = ChunkPacker.pack(chunk);
CachedWorld.this.updateCachedChunk(cached);
//System.out.println("Processed chunk at " + chunk.x + "," + chunk.z);
diff --git a/src/main/java/baritone/cache/ChunkPacker.java b/src/main/java/baritone/cache/ChunkPacker.java
index d544ac74d..5d619543d 100644
--- a/src/main/java/baritone/cache/ChunkPacker.java
+++ b/src/main/java/baritone/cache/ChunkPacker.java
@@ -34,6 +34,7 @@ import net.minecraft.world.level.chunk.PalettedContainer;
import net.minecraft.world.level.dimension.BuiltinDimensionTypes;
import net.minecraft.world.level.dimension.DimensionType;
import net.minecraft.world.phys.Vec3;
+
import java.util.*;
import static baritone.utils.BlockStateInterface.getFromChunk;
diff --git a/src/main/java/baritone/cache/FasterWorldScanner.java b/src/main/java/baritone/cache/FasterWorldScanner.java
new file mode 100644
index 000000000..5ea6dcfbe
--- /dev/null
+++ b/src/main/java/baritone/cache/FasterWorldScanner.java
@@ -0,0 +1,257 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.cache;
+
+import baritone.api.cache.ICachedWorld;
+import baritone.api.cache.IWorldScanner;
+import baritone.api.utils.BetterBlockPos;
+import baritone.api.utils.BlockOptionalMetaLookup;
+import baritone.api.utils.IPlayerContext;
+import baritone.utils.accessor.IPalettedContainer;
+import io.netty.buffer.Unpooled;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.IdMapper;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.util.BitStorage;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.chunk.*;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public enum FasterWorldScanner implements IWorldScanner {
+ INSTANCE;
+
+ @Override
+ public List scanChunkRadius(IPlayerContext ctx, BlockOptionalMetaLookup filter, int max, int yLevelThreshold, int maxSearchRadius) {
+ assert ctx.world() != null;
+ if (maxSearchRadius < 0) {
+ throw new IllegalArgumentException("chunkRange must be >= 0");
+ }
+ return scanChunksInternal(ctx, filter, getChunkRange(ctx.playerFeet().x >> 4, ctx.playerFeet().z >> 4, maxSearchRadius), max);
+ }
+
+ @Override
+ public List scanChunk(IPlayerContext ctx, BlockOptionalMetaLookup filter, ChunkPos pos, int max, int yLevelThreshold) {
+ Stream stream = scanChunkInternal(ctx, filter, pos);
+ if (max >= 0) {
+ stream = stream.limit(max);
+ }
+ return stream.collect(Collectors.toList());
+ }
+
+ @Override
+ public int repack(IPlayerContext ctx) {
+ return this.repack(ctx, 40);
+ }
+
+ @Override
+ public int repack(IPlayerContext ctx, int range) {
+ ChunkSource chunkProvider = ctx.world().getChunkSource();
+ ICachedWorld cachedWorld = ctx.worldData().getCachedWorld();
+
+ BetterBlockPos playerPos = ctx.playerFeet();
+
+ int playerChunkX = playerPos.getX() >> 4;
+ int playerChunkZ = playerPos.getZ() >> 4;
+
+ int minX = playerChunkX - range;
+ int minZ = playerChunkZ - range;
+ int maxX = playerChunkX + range;
+ int maxZ = playerChunkZ + range;
+
+ int queued = 0;
+ for (int x = minX; x <= maxX; x++) {
+ for (int z = minZ; z <= maxZ; z++) {
+ LevelChunk chunk = chunkProvider.getChunk(x, z, false);
+
+ if (chunk != null && !chunk.isEmpty()) {
+ queued++;
+ cachedWorld.queueForPacking(chunk);
+ }
+ }
+ }
+
+ return queued;
+ }
+
+ // ordered in a way that the closest blocks are generally first
+ public static List getChunkRange(int centerX, int centerZ, int chunkRadius) {
+ List chunks = new ArrayList<>();
+ // spiral out
+ chunks.add(new ChunkPos(centerX, centerZ));
+ for (int i = 1; i < chunkRadius; i++) {
+ for (int j = 0; j <= i; j++) {
+ chunks.add(new ChunkPos(centerX - j, centerZ - i));
+ if (j != 0) {
+ chunks.add(new ChunkPos(centerX + j, centerZ - i));
+ chunks.add(new ChunkPos(centerX - j, centerZ + i));
+ }
+ chunks.add(new ChunkPos(centerX + j, centerZ + i));
+ if (j != i) {
+ chunks.add(new ChunkPos(centerX - i, centerZ - j));
+ chunks.add(new ChunkPos(centerX + i, centerZ - j));
+ if (j != 0) {
+ chunks.add(new ChunkPos(centerX - i, centerZ + j));
+ chunks.add(new ChunkPos(centerX + i, centerZ + j));
+ }
+ }
+ }
+ }
+ return chunks;
+ }
+
+ private List scanChunksInternal(IPlayerContext ctx, BlockOptionalMetaLookup lookup, List chunkPositions, int maxBlocks) {
+ assert ctx.world() != null;
+ try {
+ // p -> scanChunkInternal(ctx, lookup, p)
+ Stream posStream = chunkPositions.parallelStream().flatMap(p -> scanChunkInternal(ctx, lookup, p));
+ if (maxBlocks >= 0) {
+ // WARNING: this can be expensive if maxBlocks is large...
+ // see limit's javadoc
+ posStream = posStream.limit(maxBlocks);
+ }
+ return posStream.collect(Collectors.toList());
+ } catch (Exception e) {
+ e.printStackTrace();
+ throw e;
+ }
+ }
+
+ private Stream scanChunkInternal(IPlayerContext ctx, BlockOptionalMetaLookup lookup, ChunkPos pos) {
+ ChunkSource chunkProvider = ctx.world().getChunkSource();
+ // if chunk is not loaded, return empty stream
+ if (!chunkProvider.hasChunk(pos.x, pos.z)) {
+ return Stream.empty();
+ }
+
+ long chunkX = (long) pos.x << 4;
+ long chunkZ = (long) pos.z << 4;
+
+ int playerSectionY = ctx.playerFeet().y >> 4;
+
+ return collectChunkSections(lookup, chunkProvider.getChunk(pos.x, pos.z, false), chunkX, chunkZ, playerSectionY).stream();
+ }
+
+
+ private List collectChunkSections(BlockOptionalMetaLookup lookup, LevelChunk chunk, long chunkX, long chunkZ, int playerSection) {
+ // iterate over sections relative to player
+ List blocks = new ArrayList<>();
+ LevelChunkSection[] sections = chunk.getSections();
+ int l = sections.length;
+ int i = playerSection - 1;
+ int j = playerSection;
+ for (; i >= 0 || j < l; ++j, --i) {
+ if (j < l) {
+ visitSection(lookup, sections[j], blocks, chunkX, chunkZ, j);
+ }
+ if (i >= 0) {
+ visitSection(lookup, sections[i], blocks, chunkX, chunkZ, i);
+ }
+ }
+ return blocks;
+ }
+
+ private void visitSection(BlockOptionalMetaLookup lookup, LevelChunkSection section, List blocks, long chunkX, long chunkZ, int sectionIdx) {
+ if (section == null || section.hasOnlyAir()) {
+ return;
+ }
+
+ PalettedContainer sectionContainer = section.getStates();
+ //this won't work if the PaletteStorage is of the type EmptyPaletteStorage
+ if (((IPalettedContainer) sectionContainer).getStorage() == null) {
+ return;
+ }
+
+ boolean[] isInFilter = getIncludedFilterIndices(lookup, ((IPalettedContainer) sectionContainer).getPalette());
+ if (isInFilter.length == 0) {
+ return;
+ }
+
+ BitStorage array = ((IPalettedContainer) section.getStates()).getStorage();
+ long[] longArray = array.getRaw();
+ int arraySize = array.getSize();
+ int bitsPerEntry = array.getBits();
+ long maxEntryValue = (1L << bitsPerEntry) - 1L;
+
+
+ int yOffset = sectionIdx << 4;
+
+ for (int i = 0, idx = 0; i < longArray.length && idx < arraySize; ++i) {
+ long l = longArray[i];
+ for (int offset = 0; offset <= (64 - bitsPerEntry) && idx < arraySize; offset += bitsPerEntry, ++idx) {
+ int value = (int) ((l >> offset) & maxEntryValue);
+ if (isInFilter[value]) {
+ //noinspection DuplicateExpressions
+ blocks.add(new BlockPos(
+ (int) chunkX + ((idx & 255) & 15),
+ yOffset + (idx >> 8),
+ (int) chunkZ + ((idx & 255) >> 4)
+ ));
+ }
+ }
+ }
+ }
+
+ private boolean[] getIncludedFilterIndices(BlockOptionalMetaLookup lookup, Palette palette) {
+ boolean commonBlockFound = false;
+ IdMapper paletteMap = getPalette(palette);
+ int size = paletteMap.size();
+
+ boolean[] isInFilter = new boolean[size];
+
+ for (int i = 0; i < size; i++) {
+ BlockState state = paletteMap.byId(i);
+ if (lookup.has(state)) {
+ isInFilter[i] = true;
+ commonBlockFound = true;
+ } else {
+ isInFilter[i] = false;
+ }
+ }
+
+ if (!commonBlockFound) {
+ return new boolean[0];
+ }
+ return isInFilter;
+ }
+
+ /**
+ * cheats to get the actual map of id -> blockstate from the various palette implementations
+ */
+ private static IdMapper getPalette(Palette palette) {
+ if (palette instanceof GlobalPalette) {
+ return Block.BLOCK_STATE_REGISTRY;
+ } else {
+ FriendlyByteBuf buf = new FriendlyByteBuf(Unpooled.buffer());
+ palette.write(buf);
+ int size = buf.readVarInt();
+ IdMapper states = new IdMapper<>();
+ for (int i = 0; i < size; i++) {
+ BlockState state = Block.BLOCK_STATE_REGISTRY.byId(buf.readVarInt());
+ assert state != null;
+ states.addMapping(state, i);
+ }
+ return states;
+ }
+ }
+}
diff --git a/src/main/java/baritone/cache/WorldProvider.java b/src/main/java/baritone/cache/WorldProvider.java
index f3d96a0db..035b50b98 100644
--- a/src/main/java/baritone/cache/WorldProvider.java
+++ b/src/main/java/baritone/cache/WorldProvider.java
@@ -19,104 +19,84 @@ package baritone.cache;
import baritone.Baritone;
import baritone.api.cache.IWorldProvider;
-import baritone.api.utils.Helper;
+import baritone.api.utils.IPlayerContext;
+import net.minecraft.client.multiplayer.ServerData;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.util.Tuple;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.dimension.DimensionType;
+import net.minecraft.world.level.storage.LevelResource;
import org.apache.commons.lang3.SystemUtils;
-import java.io.File;
-import java.io.FileOutputStream;
import java.io.IOException;
+import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.HashMap;
import java.util.Map;
-import java.util.function.Consumer;
-import net.minecraft.client.server.IntegratedServer;
-import net.minecraft.resources.ResourceKey;
-import net.minecraft.world.level.Level;
-import net.minecraft.world.level.dimension.DimensionType;
-import net.minecraft.world.level.storage.LevelResource;
+import java.util.Optional;
/**
* @author Brady
* @since 8/4/2018
*/
-public class WorldProvider implements IWorldProvider, Helper {
+public class WorldProvider implements IWorldProvider {
- private static final Map worldCache = new HashMap<>(); // this is how the bots have the same cached world
+ private static final Map worldCache = new HashMap<>();
+ private final Baritone baritone;
+ private final IPlayerContext ctx;
private WorldData currentWorld;
- private Level mcWorld; // this let's us detect a broken load/unload hook
+
+ /**
+ * This lets us detect a broken load/unload hook.
+ * @see #detectAndHandleBrokenLoading()
+ */
+ private Level mcWorld;
+
+ public WorldProvider(Baritone baritone) {
+ this.baritone = baritone;
+ this.ctx = baritone.getPlayerContext();
+ }
@Override
public final WorldData getCurrentWorld() {
- detectAndHandleBrokenLoading();
+ this.detectAndHandleBrokenLoading();
return this.currentWorld;
}
/**
* Called when a new world is initialized to discover the
*
- * @param world The world's Registry Data
+ * @param world The new world
*/
- public final void initWorld(ResourceKey worldKey, DimensionType world) {
- Path directory;
- Path readme;
+ public final void initWorld(Level world) {
+ this.getSaveDirectories(world).ifPresent(dirs -> {
+ final Path worldDir = dirs.getA();
+ final Path readmeDir = dirs.getB();
- IntegratedServer integratedServer = mc.getSingleplayerServer();
-
- // If there is an integrated server running (Aka Singleplayer) then do magic to find the world save file
- if (mc.hasSingleplayerServer()) {
- directory = DimensionType.getStorageFolder(worldKey, integratedServer.getWorldPath(LevelResource.ROOT));
-
- // Gets the "depth" of this directory relative the the game's run directory, 2 is the location of the world
- if (directory.relativize(mc.gameDirectory.toPath()).getNameCount() != 2) {
- // subdirectory of the main save directory for this world
- directory = directory.getParent();
- }
-
- directory = directory.resolve("baritone");
- readme = directory;
- } else { // Otherwise, the server must be remote...
- String folderName;
- if (mc.getCurrentServer() != null) {
- folderName = mc.isConnectedToRealms() ? "realms" : mc.getCurrentServer().ip;
- } else {
- //replaymod causes null currentServer and false singleplayer.
- System.out.println("World seems to be a replay. Not loading Baritone cache.");
- currentWorld = null;
- mcWorld = mc.level;
- return;
- }
- if (SystemUtils.IS_OS_WINDOWS) {
- folderName = folderName.replace(":", "_");
- }
- directory = Baritone.getDir().toPath().resolve(folderName);
- readme = Baritone.getDir().toPath();
- }
-
- // lol wtf is this baritone folder in my minecraft save?
- try (FileOutputStream out = new FileOutputStream(readme.resolve("readme.txt").toFile())) {
- // good thing we have a readme
- out.write("https://github.com/cabaletta/baritone\n".getBytes());
- } catch (IOException ignored) {}
-
- // We will actually store the world data in a subfolder: "DIM"
- Path dir = getDimDir(worldKey, world.logicalHeight(), directory);
- if (!Files.exists(dir)) {
try {
- Files.createDirectories(dir);
+ // lol wtf is this baritone folder in my minecraft save?
+ // good thing we have a readme
+ Files.createDirectories(readmeDir);
+ Files.write(
+ readmeDir.resolve("readme.txt"),
+ "https://github.com/cabaletta/baritone\n".getBytes(StandardCharsets.US_ASCII)
+ );
} catch (IOException ignored) {}
- }
- System.out.println("Baritone world data dir: " + dir);
- synchronized (worldCache) {
- this.currentWorld = worldCache.computeIfAbsent(dir, d -> new WorldData(d, world));
- }
- this.mcWorld = mc.level;
- }
+ // We will actually store the world data in a subfolder: "DIM"
+ final Path worldDataDir = this.getWorldDataDirectory(worldDir, world);
+ try {
+ Files.createDirectories(worldDataDir);
+ } catch (IOException ignored) {}
- public final Path getDimDir(ResourceKey level, int height, Path directory) {
- return directory.resolve(level.location().getNamespace()).resolve(level.location().getPath() + "_" + height);
+ System.out.println("Baritone world data dir: " + worldDataDir);
+ synchronized (worldCache) {
+ this.currentWorld = worldCache.computeIfAbsent(worldDataDir, d -> new WorldData(d, world.dimensionType()));
+ }
+ this.mcWorld = ctx.world();
+ });
}
public final void closeWorld() {
@@ -129,26 +109,73 @@ public class WorldProvider implements IWorldProvider, Helper {
world.onClose();
}
- public final void ifWorldLoaded(Consumer currentWorldConsumer) {
- detectAndHandleBrokenLoading();
- if (this.currentWorld != null) {
- currentWorldConsumer.accept(this.currentWorld);
- }
+ private Path getWorldDataDirectory(Path parent, Level world) {
+ ResourceLocation dimId = world.dimension().location();
+ int height = world.dimensionType().logicalHeight();
+ return parent.resolve(dimId.getNamespace()).resolve(dimId.getPath() + "_" + height);
}
- private final void detectAndHandleBrokenLoading() {
- if (this.mcWorld != mc.level) {
+ /**
+ * @param world The world
+ * @return An {@link Optional} containing the world's baritone dir and readme dir, or {@link Optional#empty()} if
+ * the world isn't valid for caching.
+ */
+ private Optional> getSaveDirectories(Level world) {
+ Path worldDir;
+ Path readmeDir;
+
+ // If there is an integrated server running (Aka Singleplayer) then do magic to find the world save file
+ if (ctx.minecraft().hasSingleplayerServer()) {
+ worldDir = ctx.minecraft().getSingleplayerServer().getWorldPath(LevelResource.ROOT);
+
+ // Gets the "depth" of this directory relative to the game's run directory, 2 is the location of the world
+ if (worldDir.relativize(ctx.minecraft().gameDirectory.toPath()).getNameCount() != 2) {
+ // subdirectory of the main save directory for this world
+ worldDir = worldDir.getParent();
+ }
+
+ worldDir = worldDir.resolve("baritone");
+ readmeDir = worldDir;
+ } else { // Otherwise, the server must be remote...
+ String folderName;
+ final ServerData serverData = ctx.minecraft().getCurrentServer();
+ if (serverData != null) {
+ folderName = ctx.minecraft().isConnectedToRealms() ? "realms" : serverData.ip;
+ } else {
+ //replaymod causes null currentServer and false singleplayer.
+ System.out.println("World seems to be a replay. Not loading Baritone cache.");
+ currentWorld = null;
+ mcWorld = ctx.world();
+ return Optional.empty();
+ }
+ if (SystemUtils.IS_OS_WINDOWS) {
+ folderName = folderName.replace(":", "_");
+ }
+ // TODO: This should probably be in "baritone/servers"
+ worldDir = baritone.getDirectory().resolve(folderName);
+ // Just write the readme to the baritone directory instead of each server save in it
+ readmeDir = baritone.getDirectory();
+ }
+
+ return Optional.of(new Tuple<>(worldDir, readmeDir));
+ }
+
+ /**
+ * Why does this exist instead of fixing the event? Some mods break the event. Lol.
+ */
+ private void detectAndHandleBrokenLoading() {
+ if (this.mcWorld != ctx.world()) {
if (this.currentWorld != null) {
System.out.println("mc.world unloaded unnoticed! Unloading Baritone cache now.");
closeWorld();
}
- if (mc.level != null) {
+ if (ctx.world() != null) {
System.out.println("mc.world loaded unnoticed! Loading Baritone cache now.");
- initWorld(mc.level.dimension(), mc.level.dimensionType());
+ initWorld(ctx.world());
}
- } else if (currentWorld == null && mc.level != null && (mc.hasSingleplayerServer() || mc.getCurrentServer() != null)) {
+ } else if (this.currentWorld == null && ctx.world() != null && (ctx.minecraft().hasSingleplayerServer() || ctx.minecraft().getCurrentServer() != null)) {
System.out.println("Retrying to load Baritone cache");
- initWorld(mc.level.dimension(), mc.level.dimensionType());
+ initWorld(ctx.world());
}
}
}
diff --git a/src/main/java/baritone/cache/WorldScanner.java b/src/main/java/baritone/cache/WorldScanner.java
index 2ce865a8d..35e46ba23 100644
--- a/src/main/java/baritone/cache/WorldScanner.java
+++ b/src/main/java/baritone/cache/WorldScanner.java
@@ -22,8 +22,6 @@ import baritone.api.cache.IWorldScanner;
import baritone.api.utils.BetterBlockPos;
import baritone.api.utils.BlockOptionalMetaLookup;
import baritone.api.utils.IPlayerContext;
-import java.util.*;
-import java.util.stream.IntStream;
import net.minecraft.client.multiplayer.ClientChunkCache;
import net.minecraft.core.BlockPos;
import net.minecraft.world.level.ChunkPos;
@@ -33,6 +31,9 @@ import net.minecraft.world.level.chunk.LevelChunk;
import net.minecraft.world.level.chunk.LevelChunkSection;
import net.minecraft.world.level.chunk.PalettedContainer;
+import java.util.*;
+import java.util.stream.IntStream;
+
public enum WorldScanner implements IWorldScanner {
INSTANCE;
diff --git a/src/main/java/baritone/command/ExampleBaritoneControl.java b/src/main/java/baritone/command/ExampleBaritoneControl.java
index c3c6648fe..943b8afa6 100644
--- a/src/main/java/baritone/command/ExampleBaritoneControl.java
+++ b/src/main/java/baritone/command/ExampleBaritoneControl.java
@@ -17,8 +17,8 @@
package baritone.command;
+import baritone.Baritone;
import baritone.api.BaritoneAPI;
-import baritone.api.IBaritone;
import baritone.api.Settings;
import baritone.api.command.argument.ICommandArgument;
import baritone.api.command.exception.CommandNotEnoughArgumentsException;
@@ -27,9 +27,9 @@ import baritone.api.command.helpers.TabCompleteHelper;
import baritone.api.command.manager.ICommandManager;
import baritone.api.event.events.ChatEvent;
import baritone.api.event.events.TabCompleteEvent;
-import baritone.api.event.listener.AbstractGameEventListener;
import baritone.api.utils.Helper;
import baritone.api.utils.SettingsUtil;
+import baritone.behavior.Behavior;
import baritone.command.argument.ArgConsumer;
import baritone.command.argument.CommandArguments;
import baritone.command.manager.CommandManager;
@@ -46,14 +46,14 @@ import java.util.stream.Stream;
import static baritone.api.command.IBaritoneChatControl.FORCE_COMMAND_PREFIX;
-public class ExampleBaritoneControl implements Helper, AbstractGameEventListener {
+public class ExampleBaritoneControl extends Behavior implements Helper {
private static final Settings settings = BaritoneAPI.getSettings();
private final ICommandManager manager;
- public ExampleBaritoneControl(IBaritone baritone) {
+ public ExampleBaritoneControl(Baritone baritone) {
+ super(baritone);
this.manager = baritone.getCommandManager();
- baritone.getGameEventHandler().registerEventListener(this);
}
@Override
@@ -97,7 +97,7 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
return false;
} else if (msg.trim().equalsIgnoreCase("orderpizza")) {
try {
- ((IGuiScreen) mc.screen).openLinkInvoker(new URI("https://www.dominos.com/en/pages/order/"));
+ ((IGuiScreen) ctx.minecraft().screen).openLinkInvoker(new URI("https://www.dominos.com/en/pages/order/"));
} catch (NullPointerException | URISyntaxException ignored) {}
return false;
}
@@ -121,7 +121,7 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
}
} else if (argc.hasExactlyOne()) {
for (Settings.Setting setting : settings.allSettings) {
- if (SettingsUtil.javaOnlySetting(setting)) {
+ if (setting.isJavaOnly()) {
continue;
}
if (setting.getName().equalsIgnoreCase(pair.getA())) {
@@ -174,7 +174,7 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
.stream();
}
Settings.Setting setting = settings.byLowerName.get(argc.getString().toLowerCase(Locale.US));
- if (setting != null && !SettingsUtil.javaOnlySetting(setting)) {
+ if (setting != null && !setting.isJavaOnly()) {
if (setting.getValueClass() == Boolean.class) {
TabCompleteHelper helper = new TabCompleteHelper();
if ((Boolean) setting.value) {
diff --git a/src/main/java/baritone/command/argument/ArgConsumer.java b/src/main/java/baritone/command/argument/ArgConsumer.java
index c4a6df002..99f30ce96 100644
--- a/src/main/java/baritone/command/argument/ArgConsumer.java
+++ b/src/main/java/baritone/command/argument/ArgConsumer.java
@@ -380,6 +380,8 @@ public class ArgConsumer implements IArgConsumer {
public Stream tabCompleteDatatype(T datatype) {
try {
return datatype.tabComplete(this.context);
+ } catch (CommandException ignored) {
+ // NOP
} catch (Exception e) {
e.printStackTrace();
}
diff --git a/src/main/java/baritone/command/defaults/BuildCommand.java b/src/main/java/baritone/command/defaults/BuildCommand.java
index 622aef4f8..bb34254ae 100644
--- a/src/main/java/baritone/command/defaults/BuildCommand.java
+++ b/src/main/java/baritone/command/defaults/BuildCommand.java
@@ -35,10 +35,11 @@ import java.util.stream.Stream;
public class BuildCommand extends Command {
- private static final File schematicsDir = new File(mc.gameDirectory, "schematics");
+ private final File schematicsDir;
public BuildCommand(IBaritone baritone) {
super(baritone, "build");
+ this.schematicsDir = new File(baritone.getPlayerContext().minecraft().gameDirectory, "schematics");
}
@Override
diff --git a/src/main/java/baritone/command/defaults/ComeCommand.java b/src/main/java/baritone/command/defaults/ComeCommand.java
index 5cbed55bc..b111ee1de 100644
--- a/src/main/java/baritone/command/defaults/ComeCommand.java
+++ b/src/main/java/baritone/command/defaults/ComeCommand.java
@@ -21,12 +21,11 @@ import baritone.api.IBaritone;
import baritone.api.command.Command;
import baritone.api.command.argument.IArgConsumer;
import baritone.api.command.exception.CommandException;
-import baritone.api.command.exception.CommandInvalidStateException;
import baritone.api.pathing.goals.GoalBlock;
+
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
-import net.minecraft.world.entity.Entity;
public class ComeCommand extends Command {
@@ -37,11 +36,7 @@ public class ComeCommand extends Command {
@Override
public void execute(String label, IArgConsumer args) throws CommandException {
args.requireMax(0);
- Entity entity = mc.getCameraEntity();
- if (entity == null) {
- throw new CommandInvalidStateException("render view entity is null");
- }
- baritone.getCustomGoalProcess().setGoalAndPath(new GoalBlock(entity.blockPosition()));
+ baritone.getCustomGoalProcess().setGoalAndPath(new GoalBlock(ctx.viewerPos()));
logDirect("Coming");
}
diff --git a/src/main/java/baritone/command/defaults/DefaultCommands.java b/src/main/java/baritone/command/defaults/DefaultCommands.java
index c2118ebe8..c810d07c1 100644
--- a/src/main/java/baritone/command/defaults/DefaultCommands.java
+++ b/src/main/java/baritone/command/defaults/DefaultCommands.java
@@ -66,7 +66,8 @@ public final class DefaultCommands {
new WaypointsCommand(baritone),
new CommandAlias(baritone, "sethome", "Sets your home waypoint", "waypoints save home"),
new CommandAlias(baritone, "home", "Path to your home waypoint", "waypoints goto home"),
- new SelCommand(baritone)
+ new SelCommand(baritone),
+ new ElytraCommand(baritone)
));
ExecutionControlCommands prc = new ExecutionControlCommands(baritone);
commands.add(prc.pauseCommand);
diff --git a/src/main/java/baritone/command/defaults/ElytraCommand.java b/src/main/java/baritone/command/defaults/ElytraCommand.java
new file mode 100644
index 000000000..3f7b6bfd6
--- /dev/null
+++ b/src/main/java/baritone/command/defaults/ElytraCommand.java
@@ -0,0 +1,225 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.command.defaults;
+
+import baritone.Baritone;
+import baritone.api.IBaritone;
+import baritone.api.command.Command;
+import baritone.api.command.argument.IArgConsumer;
+import baritone.api.command.exception.CommandException;
+import baritone.api.command.exception.CommandInvalidStateException;
+import baritone.api.command.helpers.TabCompleteHelper;
+import baritone.api.pathing.goals.Goal;
+import baritone.api.process.ICustomGoalProcess;
+import baritone.api.process.IElytraProcess;
+import net.minecraft.ChatFormatting;
+import net.minecraft.client.multiplayer.ServerData;
+import net.minecraft.network.chat.ClickEvent;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.HoverEvent;
+import net.minecraft.network.chat.MutableComponent;
+import net.minecraft.world.level.Level;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Stream;
+
+import static baritone.api.command.IBaritoneChatControl.FORCE_COMMAND_PREFIX;
+
+public class ElytraCommand extends Command {
+
+ public ElytraCommand(IBaritone baritone) {
+ super(baritone, "elytra");
+ }
+
+ @Override
+ public void execute(String label, IArgConsumer args) throws CommandException {
+ final ICustomGoalProcess customGoalProcess = baritone.getCustomGoalProcess();
+ final IElytraProcess elytra = baritone.getElytraProcess();
+ if (args.hasExactlyOne() && args.peekString().equals("supported")) {
+ logDirect(elytra.isLoaded() ? "yes" : unsupportedSystemMessage());
+ return;
+ }
+ if (!elytra.isLoaded()) {
+ throw new CommandInvalidStateException(unsupportedSystemMessage());
+ }
+
+ if (!args.hasAny()) {
+ if (Baritone.settings().elytraTermsAccepted.value) {
+ if (detectOn2b2t()) {
+ warn2b2t();
+ }
+ } else {
+ gatekeep();
+ }
+ Goal iGoal = customGoalProcess.mostRecentGoal();
+ if (iGoal == null) {
+ throw new CommandInvalidStateException("No goal has been set");
+ }
+ if (ctx.world().dimension() != Level.NETHER) {
+ throw new CommandInvalidStateException("Only works in the nether");
+ }
+ try {
+ elytra.pathTo(iGoal);
+ } catch (IllegalArgumentException ex) {
+ throw new CommandInvalidStateException(ex.getMessage());
+ }
+ return;
+ }
+
+ final String action = args.getString();
+ switch (action) {
+ case "reset": {
+ elytra.resetState();
+ logDirect("Reset state but still flying to same goal");
+ break;
+ }
+ case "repack": {
+ elytra.repackChunks();
+ logDirect("Queued all loaded chunks for repacking");
+ break;
+ }
+ default: {
+ throw new CommandInvalidStateException("Invalid action");
+ }
+ }
+ }
+
+ private void warn2b2t() {
+ if (Baritone.settings().elytraPredictTerrain.value) {
+ long seed = Baritone.settings().elytraNetherSeed.value;
+ if (seed != NEW_2B2T_SEED && seed != OLD_2B2T_SEED) {
+ logDirect(Component.literal("It looks like you're on 2b2t, but elytraNetherSeed is incorrect.")); // match color
+ logDirect(suggest2b2tSeeds());
+ }
+ }
+ }
+
+ private Component suggest2b2tSeeds() {
+ MutableComponent clippy = Component.literal("");
+ clippy.append("Within a few hundred blocks of spawn/axis/highways/etc, the terrain is too fragmented to be predictable. Baritone Elytra will still work, just with backtracking. ");
+ clippy.append("However, once you get more than a few thousand blocks out, you should try ");
+ MutableComponent olderSeed = Component.literal("the older seed (click here)");
+ olderSeed.setStyle(olderSeed.getStyle().withUnderlined(true).withBold(true).withHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, Component.literal(Baritone.settings().prefix.value + "set elytraNetherSeed " + OLD_2B2T_SEED))).withClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, FORCE_COMMAND_PREFIX + "set elytraNetherSeed " + OLD_2B2T_SEED)));
+ clippy.append(olderSeed);
+ clippy.append(". Once you're further out into newer terrain generation (this includes everything up through 1.12), you should try ");
+ MutableComponent newerSeed = Component.literal("the newer seed (click here)");
+ newerSeed.setStyle(newerSeed.getStyle().withUnderlined(true).withBold(true).withHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, Component.literal(Baritone.settings().prefix.value + "set elytraNetherSeed " + NEW_2B2T_SEED))).withClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, FORCE_COMMAND_PREFIX + "set elytraNetherSeed " + NEW_2B2T_SEED)));
+ clippy.append(newerSeed);
+ clippy.append(". Once you get into 1.19 terrain, the terrain becomes unpredictable again, due to custom non-vanilla generation, and you should set #elytraPredictTerrain to false. ");
+ return clippy;
+ }
+
+ private void gatekeep() {
+ MutableComponent gatekeep = Component.literal("");
+ gatekeep.append("To disable this message, enable the setting elytraTermsAccepted\n");
+ gatekeep.append("Baritone Elytra is an experimental feature. It is only intended for long distance travel in the Nether using fireworks for vanilla boost. It will not work with any other mods (\"hacks\") for non-vanilla boost. ");
+ MutableComponent gatekeep2 = Component.literal("If you want Baritone to attempt to take off from the ground for you, you can enable the elytraAutoJump setting (not advisable on laggy servers!). ");
+ gatekeep2.setStyle(gatekeep2.getStyle().withHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, Component.literal(Baritone.settings().prefix.value + "set elytraAutoJump true"))));
+ gatekeep.append(gatekeep2);
+ MutableComponent gatekeep3 = Component.literal("If you want Baritone to go slower, enable the elytraConserveFireworks setting and/or decrease the elytraFireworkSpeed setting. ");
+ gatekeep3.setStyle(gatekeep3.getStyle().withHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, Component.literal(Baritone.settings().prefix.value + "set elytraConserveFireworks true\n" + Baritone.settings().prefix.value + "set elytraFireworkSpeed 0.6\n(the 0.6 number is just an example, tweak to your liking)"))));
+ gatekeep.append(gatekeep3);
+ MutableComponent gatekeep4 = Component.literal("Baritone Elytra ");
+ MutableComponent red = Component.literal("wants to know the seed");
+ red.setStyle(red.getStyle().withColor(ChatFormatting.RED).withUnderlined(true).withBold(true));
+ gatekeep4.append(red);
+ gatekeep4.append(" of the world you are in. If it doesn't have the correct seed, it will frequently backtrack. It uses the seed to generate terrain far beyond what you can see, since terrain obstacles in the Nether can be much larger than your render distance. ");
+ gatekeep.append(gatekeep4);
+ gatekeep.append("\n");
+ if (detectOn2b2t()) {
+ MutableComponent gatekeep5 = Component.literal("It looks like you're on 2b2t. ");
+ gatekeep5.append(suggest2b2tSeeds());
+ if (!Baritone.settings().elytraPredictTerrain.value) {
+ gatekeep5.append(Baritone.settings().prefix.value + "elytraPredictTerrain is currently disabled. ");
+ } else {
+ if (Baritone.settings().elytraNetherSeed.value == NEW_2B2T_SEED) {
+ gatekeep5.append("You are using the newer seed. ");
+ } else if (Baritone.settings().elytraNetherSeed.value == OLD_2B2T_SEED) {
+ gatekeep5.append("You are using the older seed. ");
+ } else {
+ gatekeep5.append("Defaulting to the newer seed. ");
+ Baritone.settings().elytraNetherSeed.value = NEW_2B2T_SEED;
+ }
+ }
+ gatekeep.append(gatekeep5);
+ } else {
+ if (Baritone.settings().elytraNetherSeed.value == NEW_2B2T_SEED) {
+ MutableComponent gatekeep5 = Component.literal("Baritone doesn't know the seed of your world. Set it with: " + Baritone.settings().prefix.value + "set elytraNetherSeed seedgoeshere\n");
+ gatekeep5.append("For the time being, elytraPredictTerrain is defaulting to false since the seed is unknown.");
+ gatekeep.append(gatekeep5);
+ Baritone.settings().elytraPredictTerrain.value = false;
+ } else {
+ if (Baritone.settings().elytraPredictTerrain.value) {
+ MutableComponent gatekeep5 = Component.literal("Baritone Elytra is predicting terrain assuming that " + Baritone.settings().elytraNetherSeed.value + " is the correct seed. Change that with " + Baritone.settings().prefix.value + "set elytraNetherSeed seedgoeshere, or disable it with " + Baritone.settings().prefix.value + "set elytraPredictTerrain false");
+ gatekeep.append(gatekeep5);
+ } else {
+ MutableComponent gatekeep5 = Component.literal("Baritone Elytra is not predicting terrain. If you don't know the seed, this is the correct thing to do. If you do know the seed, input it with " + Baritone.settings().prefix.value + "set elytraNetherSeed seedgoeshere, and then enable it with " + Baritone.settings().prefix.value + "set elytraPredictTerrain true");
+ gatekeep.append(gatekeep5);
+ }
+ }
+ }
+ logDirect(gatekeep);
+ }
+
+ private boolean detectOn2b2t() {
+ ServerData data = ctx.minecraft().getCurrentServer();
+ return data != null && data.ip.toLowerCase().contains("2b2t.org");
+ }
+
+ private static final long OLD_2B2T_SEED = -4100785268875389365L;
+ private static final long NEW_2B2T_SEED = 146008555100680L;
+
+ @Override
+ public Stream tabComplete(String label, IArgConsumer args) throws CommandException {
+ TabCompleteHelper helper = new TabCompleteHelper();
+ if (args.hasExactlyOne()) {
+ helper.append("reset", "repack", "supported");
+ }
+ return helper.filterPrefix(args.getString()).stream();
+ }
+
+ @Override
+ public String getShortDesc() {
+ return "elytra time";
+ }
+
+ @Override
+ public List getLongDesc() {
+ return Arrays.asList(
+ "The elytra command tells baritone to, in the nether, automatically fly to the current goal.",
+ "",
+ "Usage:",
+ "> elytra - fly to the current goal",
+ "> elytra reset - Resets the state of the process, but will try to keep flying to the same goal.",
+ "> elytra repack - Queues all of the chunks in render distance to be given to the native library.",
+ "> elytra supported - Tells you if baritone ships a native library that is compatible with your PC."
+ );
+ }
+
+ private static String unsupportedSystemMessage() {
+ final String osArch = System.getProperty("os.arch");
+ final String osName = System.getProperty("os.name");
+ return String.format(
+ "Legacy architectures are not supported. Your CPU is %s and your operating system is %s. " +
+ "Supported architectures are 64 bit x86, and 64 bit ARM. Supported operating systems are Windows, " +
+ "Linux, and Mac",
+ osArch, osName
+ );
+ }
+}
diff --git a/src/main/java/baritone/command/defaults/ExploreFilterCommand.java b/src/main/java/baritone/command/defaults/ExploreFilterCommand.java
index 504f7c146..ecb5f8376 100644
--- a/src/main/java/baritone/command/defaults/ExploreFilterCommand.java
+++ b/src/main/java/baritone/command/defaults/ExploreFilterCommand.java
@@ -41,7 +41,7 @@ public class ExploreFilterCommand extends Command {
@Override
public void execute(String label, IArgConsumer args) throws CommandException {
args.requireMax(2);
- File file = args.getDatatypePost(RelativeFile.INSTANCE, mc.gameDirectory.getAbsoluteFile().getParentFile());
+ File file = args.getDatatypePost(RelativeFile.INSTANCE, ctx.minecraft().gameDirectory.getAbsoluteFile().getParentFile());
boolean invert = false;
if (args.hasAny()) {
if (args.getString().equalsIgnoreCase("invert")) {
@@ -65,7 +65,7 @@ public class ExploreFilterCommand extends Command {
@Override
public Stream tabComplete(String label, IArgConsumer args) throws CommandException {
if (args.hasExactlyOne()) {
- return RelativeFile.tabComplete(args, RelativeFile.gameDir());
+ return RelativeFile.tabComplete(args, RelativeFile.gameDir(ctx.minecraft()));
}
return Stream.empty();
}
diff --git a/src/main/java/baritone/command/defaults/GoalCommand.java b/src/main/java/baritone/command/defaults/GoalCommand.java
index 40822e057..a174ecad9 100644
--- a/src/main/java/baritone/command/defaults/GoalCommand.java
+++ b/src/main/java/baritone/command/defaults/GoalCommand.java
@@ -51,7 +51,7 @@ public class GoalCommand extends Command {
}
} else {
args.requireMax(3);
- BetterBlockPos origin = baritone.getPlayerContext().playerFeet();
+ BetterBlockPos origin = ctx.playerFeet();
Goal goal = args.getDatatypePost(RelativeGoal.INSTANCE, origin);
goalProcess.setGoal(goal);
logDirect(String.format("Goal: %s", goal.toString()));
diff --git a/src/main/java/baritone/command/defaults/GotoCommand.java b/src/main/java/baritone/command/defaults/GotoCommand.java
index 896e3f5f8..c64d7fa00 100644
--- a/src/main/java/baritone/command/defaults/GotoCommand.java
+++ b/src/main/java/baritone/command/defaults/GotoCommand.java
@@ -20,7 +20,6 @@ package baritone.command.defaults;
import baritone.api.IBaritone;
import baritone.api.command.Command;
import baritone.api.command.argument.IArgConsumer;
-import baritone.api.command.datatypes.BlockById;
import baritone.api.command.datatypes.ForBlockOptionalMeta;
import baritone.api.command.datatypes.RelativeCoordinate;
import baritone.api.command.datatypes.RelativeGoal;
@@ -46,7 +45,7 @@ public class GotoCommand extends Command {
// is no need to handle the case of empty arguments.
if (args.peekDatatypeOrNull(RelativeCoordinate.INSTANCE) != null) {
args.requireMax(3);
- BetterBlockPos origin = baritone.getPlayerContext().playerFeet();
+ BetterBlockPos origin = ctx.playerFeet();
Goal goal = args.getDatatypePost(RelativeGoal.INSTANCE, origin);
logDirect(String.format("Going to: %s", goal.toString()));
baritone.getCustomGoalProcess().setGoalAndPath(goal);
@@ -61,7 +60,8 @@ public class GotoCommand extends Command {
public Stream tabComplete(String label, IArgConsumer args) throws CommandException {
// since it's either a goal or a block, I don't think we can tab complete properly?
// so just tab complete for the block variant
- return args.tabCompleteDatatype(BlockById.INSTANCE);
+ args.requireMax(1);
+ return args.tabCompleteDatatype(ForBlockOptionalMeta.INSTANCE);
}
@Override
diff --git a/src/main/java/baritone/command/defaults/MineCommand.java b/src/main/java/baritone/command/defaults/MineCommand.java
index 98a2e264d..eb2c22c6d 100644
--- a/src/main/java/baritone/command/defaults/MineCommand.java
+++ b/src/main/java/baritone/command/defaults/MineCommand.java
@@ -17,14 +17,13 @@
package baritone.command.defaults;
+import baritone.api.BaritoneAPI;
import baritone.api.IBaritone;
import baritone.api.command.Command;
import baritone.api.command.argument.IArgConsumer;
-import baritone.api.command.datatypes.BlockById;
import baritone.api.command.datatypes.ForBlockOptionalMeta;
import baritone.api.command.exception.CommandException;
import baritone.api.utils.BlockOptionalMeta;
-import baritone.cache.WorldScanner;
import java.util.ArrayList;
import java.util.Arrays;
@@ -45,14 +44,18 @@ public class MineCommand extends Command {
while (args.hasAny()) {
boms.add(args.getDatatypeFor(ForBlockOptionalMeta.INSTANCE));
}
- WorldScanner.INSTANCE.repack(ctx);
+ BaritoneAPI.getProvider().getWorldScanner().repack(ctx);
logDirect(String.format("Mining %s", boms.toString()));
baritone.getMineProcess().mine(quantity, boms.toArray(new BlockOptionalMeta[0]));
}
@Override
- public Stream tabComplete(String label, IArgConsumer args) {
- return args.tabCompleteDatatype(BlockById.INSTANCE);
+ public Stream tabComplete(String label, IArgConsumer args) throws CommandException {
+ args.getAsOrDefault(Integer.class, 0);
+ while (args.has(2)) {
+ args.getDatatypeFor(ForBlockOptionalMeta.INSTANCE);
+ }
+ return args.tabCompleteDatatype(ForBlockOptionalMeta.INSTANCE);
}
@Override
diff --git a/src/main/java/baritone/command/defaults/PathCommand.java b/src/main/java/baritone/command/defaults/PathCommand.java
index 182a1e5bc..b2021adf6 100644
--- a/src/main/java/baritone/command/defaults/PathCommand.java
+++ b/src/main/java/baritone/command/defaults/PathCommand.java
@@ -17,12 +17,12 @@
package baritone.command.defaults;
+import baritone.api.BaritoneAPI;
import baritone.api.IBaritone;
import baritone.api.command.Command;
import baritone.api.command.argument.IArgConsumer;
import baritone.api.command.exception.CommandException;
import baritone.api.process.ICustomGoalProcess;
-import baritone.cache.WorldScanner;
import java.util.Arrays;
import java.util.List;
@@ -38,7 +38,7 @@ public class PathCommand extends Command {
public void execute(String label, IArgConsumer args) throws CommandException {
ICustomGoalProcess customGoalProcess = baritone.getCustomGoalProcess();
args.requireMax(0);
- WorldScanner.INSTANCE.repack(ctx);
+ BaritoneAPI.getProvider().getWorldScanner().repack(ctx);
customGoalProcess.path();
logDirect("Now pathing");
}
diff --git a/src/main/java/baritone/command/defaults/RenderCommand.java b/src/main/java/baritone/command/defaults/RenderCommand.java
index 39dc6ea7c..543c3387c 100644
--- a/src/main/java/baritone/command/defaults/RenderCommand.java
+++ b/src/main/java/baritone/command/defaults/RenderCommand.java
@@ -37,8 +37,8 @@ public class RenderCommand extends Command {
public void execute(String label, IArgConsumer args) throws CommandException {
args.requireMax(0);
BetterBlockPos origin = ctx.playerFeet();
- int renderDistance = (mc.options.renderDistance().get() + 1) * 16;
- mc.levelRenderer.setBlocksDirty(
+ int renderDistance = (ctx.minecraft().options.renderDistance().get() + 1) * 16;
+ ctx.minecraft().levelRenderer.setBlocksDirty(
origin.x - renderDistance,
0,
origin.z - renderDistance,
diff --git a/src/main/java/baritone/command/defaults/RepackCommand.java b/src/main/java/baritone/command/defaults/RepackCommand.java
index cafbea524..9f972561d 100644
--- a/src/main/java/baritone/command/defaults/RepackCommand.java
+++ b/src/main/java/baritone/command/defaults/RepackCommand.java
@@ -17,11 +17,11 @@
package baritone.command.defaults;
+import baritone.api.BaritoneAPI;
import baritone.api.IBaritone;
import baritone.api.command.Command;
import baritone.api.command.argument.IArgConsumer;
import baritone.api.command.exception.CommandException;
-import baritone.cache.WorldScanner;
import java.util.Arrays;
import java.util.List;
@@ -36,7 +36,7 @@ public class RepackCommand extends Command {
@Override
public void execute(String label, IArgConsumer args) throws CommandException {
args.requireMax(0);
- logDirect(String.format("Queued %d chunks for repacking", WorldScanner.INSTANCE.repack(ctx)));
+ logDirect(String.format("Queued %d chunks for repacking", BaritoneAPI.getProvider().getWorldScanner().repack(ctx)));
}
@Override
diff --git a/src/main/java/baritone/command/defaults/SelCommand.java b/src/main/java/baritone/command/defaults/SelCommand.java
index c5b82932d..14d22b0b4 100644
--- a/src/main/java/baritone/command/defaults/SelCommand.java
+++ b/src/main/java/baritone/command/defaults/SelCommand.java
@@ -21,6 +21,7 @@ import baritone.Baritone;
import baritone.api.IBaritone;
import baritone.api.command.Command;
import baritone.api.command.argument.IArgConsumer;
+import baritone.api.command.datatypes.ForAxis;
import baritone.api.command.datatypes.ForBlockOptionalMeta;
import baritone.api.command.datatypes.ForDirection;
import baritone.api.command.datatypes.RelativeBlockPos;
@@ -31,6 +32,8 @@ import baritone.api.command.helpers.TabCompleteHelper;
import baritone.api.event.events.RenderEvent;
import baritone.api.event.listener.AbstractGameEventListener;
import baritone.api.schematic.*;
+import baritone.api.schematic.mask.shape.CylinderMask;
+import baritone.api.schematic.mask.shape.SphereMask;
import baritone.api.selection.ISelection;
import baritone.api.selection.ISelectionManager;
import baritone.api.utils.BetterBlockPos;
@@ -50,6 +53,7 @@ import java.awt.*;
import java.util.*;
import java.util.List;
import java.util.function.Function;
+import java.util.function.UnaryOperator;
import java.util.stream.Stream;
public class SelCommand extends Command {
@@ -72,7 +76,7 @@ public class SelCommand extends Command {
float lineWidth = Baritone.settings().selectionLineWidth.value;
boolean ignoreDepth = Baritone.settings().renderSelectionIgnoreDepth.value;
IRenderer.startLines(color, opacity, lineWidth, ignoreDepth);
- IRenderer.drawAABB(event.getModelViewStack(), new AABB(pos1, pos1.offset(1, 1, 1)));
+ IRenderer.emitAABB(event.getModelViewStack(), new AABB(pos1, pos1.offset(1, 1, 1)));
IRenderer.endLines(ignoreDepth);
}
});
@@ -88,7 +92,7 @@ public class SelCommand extends Command {
if (action == Action.POS2 && pos1 == null) {
throw new CommandInvalidStateException("Set pos1 first before using pos2");
}
- BetterBlockPos playerPos = mc.getCameraEntity() != null ? BetterBlockPos.from(mc.getCameraEntity().blockPosition()) : ctx.playerFeet();
+ BetterBlockPos playerPos = ctx.viewerPos();
BetterBlockPos pos = args.hasAny() ? args.getDatatypePost(RelativeBlockPos.INSTANCE, playerPos) : playerPos;
args.requireMax(0);
if (action == Action.POS1) {
@@ -117,11 +121,13 @@ public class SelCommand extends Command {
logDirect("Undid pos2");
}
}
- } else if (action == Action.SET || action == Action.WALLS || action == Action.SHELL || action == Action.CLEARAREA || action == Action.REPLACE) {
+ } else if (action.isFillAction()) {
BlockOptionalMeta type = action == Action.CLEARAREA
? new BlockOptionalMeta(Blocks.AIR)
: args.getDatatypeFor(ForBlockOptionalMeta.INSTANCE);
- BlockOptionalMetaLookup replaces = null;
+
+ final BlockOptionalMetaLookup replaces; // Action.REPLACE
+ final Direction.Axis alignment; // Action.(H)CYLINDER
if (action == Action.REPLACE) {
args.requireMin(1);
List replacesList = new ArrayList<>();
@@ -131,8 +137,15 @@ public class SelCommand extends Command {
}
type = args.getDatatypeFor(ForBlockOptionalMeta.INSTANCE);
replaces = new BlockOptionalMetaLookup(replacesList.toArray(new BlockOptionalMeta[0]));
+ alignment = null;
+ } else if (action == Action.CYLINDER || action == Action.HCYLINDER) {
+ args.requireMax(1);
+ alignment = args.hasAny() ? args.getDatatypeFor(ForAxis.INSTANCE) : Direction.Axis.Y;
+ replaces = null;
} else {
args.requireMax(0);
+ replaces = null;
+ alignment = null;
}
ISelection[] selections = manager.getSelections();
if (selections.length == 0) {
@@ -151,20 +164,41 @@ public class SelCommand extends Command {
for (ISelection selection : selections) {
Vec3i size = selection.size();
BetterBlockPos min = selection.min();
- ISchematic schematic = new FillSchematic(size.getX(), size.getY(), size.getZ(), type);
- if (action == Action.WALLS) {
- schematic = new WallsSchematic(schematic);
- } else if (action == Action.SHELL) {
- schematic = new ShellSchematic(schematic);
- } else if (action == Action.REPLACE) {
- schematic = new ReplaceSchematic(schematic, replaces);
- }
+
+ // Java 8 so no switch expressions 😿
+ UnaryOperator create = fill -> {
+ final int w = fill.widthX();
+ final int h = fill.heightY();
+ final int l = fill.lengthZ();
+
+ switch (action) {
+ case WALLS:
+ return new WallsSchematic(fill);
+ case SHELL:
+ return new ShellSchematic(fill);
+ case REPLACE:
+ return new ReplaceSchematic(fill, replaces);
+ case SPHERE:
+ return MaskSchematic.create(fill, new SphereMask(w, h, l, true).compute());
+ case HSPHERE:
+ return MaskSchematic.create(fill, new SphereMask(w, h, l, false).compute());
+ case CYLINDER:
+ return MaskSchematic.create(fill, new CylinderMask(w, h, l, true, alignment).compute());
+ case HCYLINDER:
+ return MaskSchematic.create(fill, new CylinderMask(w, h, l, false, alignment).compute());
+ default:
+ // Silent fail
+ return fill;
+ }
+ };
+
+ ISchematic schematic = create.apply(new FillSchematic(size.getX(), size.getY(), size.getZ(), type));
composite.put(schematic, min.x - origin.x, min.y - origin.y, min.z - origin.z);
}
baritone.getBuilderProcess().build("Fill", composite, origin);
logDirect("Filling now");
} else if (action == Action.COPY) {
- BetterBlockPos playerPos = mc.getCameraEntity() != null ? BetterBlockPos.from(mc.getCameraEntity().blockPosition()) : ctx.playerFeet();
+ BetterBlockPos playerPos = ctx.viewerPos();
BetterBlockPos pos = args.hasAny() ? args.getDatatypePost(RelativeBlockPos.INSTANCE, playerPos) : playerPos;
args.requireMax(0);
ISelection[] selections = manager.getSelections();
@@ -205,7 +239,7 @@ public class SelCommand extends Command {
clipboardOffset = origin.subtract(pos);
logDirect("Selection copied");
} else if (action == Action.PASTE) {
- BetterBlockPos playerPos = mc.getCameraEntity() != null ? BetterBlockPos.from(mc.getCameraEntity().blockPosition()) : ctx.playerFeet();
+ BetterBlockPos playerPos = ctx.viewerPos();
BetterBlockPos pos = args.hasAny() ? args.getDatatypePost(RelativeBlockPos.INSTANCE, playerPos) : playerPos;
args.requireMax(0);
if (clipboard == null) {
@@ -254,12 +288,15 @@ public class SelCommand extends Command {
if (args.hasAtMost(3)) {
return args.tabCompleteDatatype(RelativeBlockPos.INSTANCE);
}
- } else if (action == Action.SET || action == Action.WALLS || action == Action.CLEARAREA || action == Action.REPLACE) {
+ } else if (action.isFillAction()) {
if (args.hasExactlyOne() || action == Action.REPLACE) {
while (args.has(2)) {
args.get();
}
return args.tabCompleteDatatype(ForBlockOptionalMeta.INSTANCE);
+ } else if (args.hasExactly(2) && (action == Action.CYLINDER || action == Action.HCYLINDER)) {
+ args.get();
+ return args.tabCompleteDatatype(ForAxis.INSTANCE);
}
} else if (action == Action.EXPAND || action == Action.CONTRACT || action == Action.SHIFT) {
if (args.hasExactlyOne()) {
@@ -305,6 +342,10 @@ public class SelCommand extends Command {
"> sel set/fill/s/f [block] - Completely fill all selections with a block.",
"> sel walls/w [block] - Fill in the walls of the selection with a specified block.",
"> sel shell/shl [block] - The same as walls, but fills in a ceiling and floor too.",
+ "> sel sphere/sph [block] - Fills the selection with a sphere bounded by the sides.",
+ "> sel hsphere/hsph [block] - The same as sphere, but hollow.",
+ "> sel cylinder/cyl [block] - Fills the selection with a cylinder bounded by the sides, oriented about the given axis. (default=y)",
+ "> sel hcylinder/hcyl [block] - The same as cylinder, but hollow.",
"> sel cleararea/ca - Basically 'set air'.",
"> sel replace/r - Replaces blocks with another block.",
"> sel copy/cp - Copy the selected area relative to the specified or your position.",
@@ -324,6 +365,10 @@ public class SelCommand extends Command {
SET("set", "fill", "s", "f"),
WALLS("walls", "w"),
SHELL("shell", "shl"),
+ SPHERE("sphere", "sph"),
+ HSPHERE("hsphere", "hsph"),
+ CYLINDER("cylinder", "cyl"),
+ HCYLINDER("hcylinder", "hcyl"),
CLEARAREA("cleararea", "ca"),
REPLACE("replace", "r"),
EXPAND("expand", "ex"),
@@ -355,6 +400,18 @@ public class SelCommand extends Command {
}
return names.toArray(new String[0]);
}
+
+ public final boolean isFillAction() {
+ return this == SET
+ || this == WALLS
+ || this == SHELL
+ || this == SPHERE
+ || this == HSPHERE
+ || this == CYLINDER
+ || this == HCYLINDER
+ || this == CLEARAREA
+ || this == REPLACE;
+ }
}
enum TransformTarget {
diff --git a/src/main/java/baritone/command/defaults/SetCommand.java b/src/main/java/baritone/command/defaults/SetCommand.java
index 3d70c16b9..0f4439cef 100644
--- a/src/main/java/baritone/command/defaults/SetCommand.java
+++ b/src/main/java/baritone/command/defaults/SetCommand.java
@@ -22,23 +22,25 @@ import baritone.api.IBaritone;
import baritone.api.Settings;
import baritone.api.command.Command;
import baritone.api.command.argument.IArgConsumer;
+import baritone.api.command.datatypes.RelativeFile;
import baritone.api.command.exception.CommandException;
import baritone.api.command.exception.CommandInvalidStateException;
import baritone.api.command.exception.CommandInvalidTypeException;
import baritone.api.command.helpers.Paginator;
import baritone.api.command.helpers.TabCompleteHelper;
import baritone.api.utils.SettingsUtil;
+import net.minecraft.ChatFormatting;
+import net.minecraft.client.Minecraft;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.ClickEvent;
+import net.minecraft.network.chat.HoverEvent;
+import net.minecraft.network.chat.MutableComponent;
-import java.awt.*;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;
import java.util.stream.Collectors;
import java.util.stream.Stream;
-import net.minecraft.ChatFormatting;
-import net.minecraft.network.chat.*;
-import net.minecraft.network.chat.Component;
-import net.minecraft.network.chat.MutableComponent;
import static baritone.api.command.IBaritoneChatControl.FORCE_COMMAND_PREFIX;
import static baritone.api.utils.SettingsUtil.*;
@@ -57,6 +59,18 @@ public class SetCommand extends Command {
logDirect("Settings saved");
return;
}
+ if (Arrays.asList("load", "ld").contains(arg)) {
+ String file = SETTINGS_DEFAULT_NAME;
+ if (args.hasAny()) {
+ file = args.getString();
+ }
+ // reset to defaults
+ SettingsUtil.modifiedSettings(Baritone.settings()).forEach(Settings.Setting::reset);
+ // then load from disk
+ SettingsUtil.readAndApply(Baritone.settings(), file);
+ logDirect("Settings reloaded from " + file);
+ return;
+ }
boolean viewModified = Arrays.asList("m", "mod", "modified").contains(arg);
boolean viewAll = Arrays.asList("all", "l", "list").contains(arg);
boolean paginate = viewModified || viewAll;
@@ -65,7 +79,7 @@ public class SetCommand extends Command {
args.requireMax(1);
List toPaginate =
(viewModified ? SettingsUtil.modifiedSettings(Baritone.settings()) : Baritone.settings().allSettings).stream()
- .filter(s -> !javaOnlySetting(s))
+ .filter(s -> !s.isJavaOnly())
.filter(s -> s.getName().toLowerCase(Locale.US).contains(search.toLowerCase(Locale.US)))
.sorted((s1, s2) -> String.CASE_INSENSITIVE_ORDER.compare(s1.getName(), s2.getName()))
.collect(Collectors.toList());
@@ -129,7 +143,7 @@ public class SetCommand extends Command {
if (setting == null) {
throw new CommandInvalidTypeException(args.consumed(), "a valid setting");
}
- if (javaOnlySetting(setting)) {
+ if (setting.isJavaOnly()) {
// ideally it would act as if the setting didn't exist
// but users will see it in Settings.java or its javadoc
// so at some point we have to tell them or they will see it as a bug
@@ -209,6 +223,9 @@ public class SetCommand extends Command {
.addToggleableSettings()
.filterPrefix(args.getString())
.stream();
+ } else if (Arrays.asList("ld", "load").contains(arg.toLowerCase(Locale.US))) {
+ // settings always use the directory of the main Minecraft instance
+ return RelativeFile.tabComplete(args, Minecraft.getInstance().gameDirectory.toPath().resolve("baritone").toFile());
}
Settings.Setting setting = Baritone.settings().byLowerName.get(arg.toLowerCase(Locale.US));
if (setting != null) {
@@ -228,7 +245,7 @@ public class SetCommand extends Command {
return new TabCompleteHelper()
.addSettings()
.sortAlphabetically()
- .prepend("list", "modified", "reset", "toggle", "save")
+ .prepend("list", "modified", "reset", "toggle", "save", "load")
.filterPrefix(arg)
.stream();
}
@@ -255,7 +272,9 @@ public class SetCommand extends Command {
"> set reset all - Reset ALL SETTINGS to their defaults",
"> set reset - Reset a setting to its default",
"> set toggle - Toggle a boolean setting",
- "> set save - Save all settings (this is automatic tho)"
+ "> set save - Save all settings (this is automatic tho)",
+ "> set load - Load settings from settings.txt",
+ "> set load [filename] - Load settings from another file in your minecraft/baritone"
);
}
}
diff --git a/src/main/java/baritone/command/defaults/SurfaceCommand.java b/src/main/java/baritone/command/defaults/SurfaceCommand.java
index 3bbd4d738..a9c981cc3 100644
--- a/src/main/java/baritone/command/defaults/SurfaceCommand.java
+++ b/src/main/java/baritone/command/defaults/SurfaceCommand.java
@@ -37,13 +37,13 @@ public class SurfaceCommand extends Command {
@Override
public void execute(String label, IArgConsumer args) throws CommandException {
- final BetterBlockPos playerPos = baritone.getPlayerContext().playerFeet();
- final int surfaceLevel = baritone.getPlayerContext().world().getSeaLevel();
- final int worldHeight = baritone.getPlayerContext().world().getHeight();
+ final BetterBlockPos playerPos = ctx.playerFeet();
+ final int surfaceLevel = ctx.world().getSeaLevel();
+ final int worldHeight = ctx.world().getHeight();
// Ensure this command will not run if you are above the surface level and the block above you is air
// As this would imply that your are already on the open surface
- if (playerPos.getY() > surfaceLevel && mc.level.getBlockState(playerPos.above()).getBlock() instanceof AirBlock) {
+ if (playerPos.getY() > surfaceLevel && ctx.world().getBlockState(playerPos.above()).getBlock() instanceof AirBlock) {
logDirect("Already at surface");
return;
}
@@ -53,7 +53,7 @@ public class SurfaceCommand extends Command {
for (int currentIteratedY = startingYPos; currentIteratedY < worldHeight; currentIteratedY++) {
final BetterBlockPos newPos = new BetterBlockPos(playerPos.getX(), currentIteratedY, playerPos.getZ());
- if (!(mc.level.getBlockState(newPos).getBlock() instanceof AirBlock) && newPos.getY() > playerPos.getY()) {
+ if (!(ctx.world().getBlockState(newPos).getBlock() instanceof AirBlock) && newPos.getY() > playerPos.getY()) {
Goal goal = new GoalBlock(newPos.above());
logDirect(String.format("Going to: %s", goal.toString()));
baritone.getCustomGoalProcess().setGoalAndPath(goal);
diff --git a/src/main/java/baritone/command/defaults/WaypointsCommand.java b/src/main/java/baritone/command/defaults/WaypointsCommand.java
index 56a833517..6e7f0a1e5 100644
--- a/src/main/java/baritone/command/defaults/WaypointsCommand.java
+++ b/src/main/java/baritone/command/defaults/WaypointsCommand.java
@@ -149,7 +149,11 @@ public class WaypointsCommand extends Command {
logDirect(component);
} else if (action == Action.CLEAR) {
args.requireMax(1);
- IWaypoint.Tag tag = IWaypoint.Tag.getByName(args.getString());
+ String name = args.getString();
+ IWaypoint.Tag tag = IWaypoint.Tag.getByName(name);
+ if (tag == null) {
+ throw new CommandInvalidStateException("Invalid tag, \"" + name + "\"");
+ }
IWaypoint[] waypoints = ForWaypoints.getWaypointsByTag(this.baritone, tag);
for (IWaypoint waypoint : waypoints) {
ForWaypoints.waypoints(this.baritone).removeWaypoint(waypoint);
diff --git a/src/main/java/baritone/command/manager/CommandManager.java b/src/main/java/baritone/command/manager/CommandManager.java
index 4c33226d3..8712165f1 100644
--- a/src/main/java/baritone/command/manager/CommandManager.java
+++ b/src/main/java/baritone/command/manager/CommandManager.java
@@ -21,6 +21,7 @@ import baritone.Baritone;
import baritone.api.IBaritone;
import baritone.api.command.ICommand;
import baritone.api.command.argument.ICommandArgument;
+import baritone.api.command.exception.CommandException;
import baritone.api.command.exception.CommandUnhandledException;
import baritone.api.command.exception.ICommandException;
import baritone.api.command.helpers.TabCompleteHelper;
@@ -153,9 +154,12 @@ public class CommandManager implements ICommandManager {
private Stream tabComplete() {
try {
return this.command.tabComplete(this.label, this.args);
+ } catch (CommandException ignored) {
+ // NOP
} catch (Throwable t) {
- return Stream.empty();
+ t.printStackTrace();
}
+ return Stream.empty();
}
}
}
diff --git a/src/main/java/baritone/event/GameEventHandler.java b/src/main/java/baritone/event/GameEventHandler.java
index b7853e360..d716ff849 100644
--- a/src/main/java/baritone/event/GameEventHandler.java
+++ b/src/main/java/baritone/event/GameEventHandler.java
@@ -23,12 +23,17 @@ import baritone.api.event.events.type.EventState;
import baritone.api.event.listener.IEventBus;
import baritone.api.event.listener.IGameEventListener;
import baritone.api.utils.Helper;
+import baritone.api.utils.Pair;
+import baritone.cache.CachedChunk;
import baritone.cache.WorldProvider;
import baritone.utils.BlockStateInterface;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.chunk.LevelChunk;
+
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
-import net.minecraft.world.level.Level;
-import net.minecraft.world.level.chunk.LevelChunk;
/**
* @author Brady
@@ -59,6 +64,11 @@ public final class GameEventHandler implements IEventBus, Helper {
listeners.forEach(l -> l.onTick(event));
}
+ @Override
+ public void onPostTick(TickEvent event) {
+ listeners.forEach(l -> l.onPostTick(event));
+ }
+
@Override
public final void onPlayerUpdate(PlayerUpdateEvent event) {
listeners.forEach(l -> l.onPlayerUpdate(event));
@@ -75,13 +85,10 @@ public final class GameEventHandler implements IEventBus, Helper {
}
@Override
- public final void onChunkEvent(ChunkEvent event) {
+ public void onChunkEvent(ChunkEvent event) {
EventState state = event.getState();
ChunkEvent.Type type = event.getType();
- boolean isPostPopulate = state == EventState.POST
- && (type == ChunkEvent.Type.POPULATE_FULL || type == ChunkEvent.Type.POPULATE_PARTIAL);
-
Level world = baritone.getPlayerContext().world();
// Whenever the server sends us to another dimension, chunks are unloaded
@@ -91,7 +98,7 @@ public final class GameEventHandler implements IEventBus, Helper {
&& type == ChunkEvent.Type.UNLOAD
&& world.getChunkSource().getChunk(event.getX(), event.getZ(), null, false) != null;
- if (isPostPopulate || isPreUnload) {
+ if (event.isPostPopulate() || isPreUnload) {
baritone.getWorldProvider().ifWorldLoaded(worldData -> {
LevelChunk chunk = world.getChunk(event.getX(), event.getZ());
worldData.getCachedWorld().queueForPacking(chunk);
@@ -102,6 +109,25 @@ public final class GameEventHandler implements IEventBus, Helper {
listeners.forEach(l -> l.onChunkEvent(event));
}
+ @Override
+ public void onBlockChange(BlockChangeEvent event) {
+ if (Baritone.settings().repackOnAnyBlockChange.value) {
+ final boolean keepingTrackOf = event.getBlocks().stream()
+ .map(Pair::second).map(BlockState::getBlock)
+ .anyMatch(CachedChunk.BLOCKS_TO_KEEP_TRACK_OF::contains);
+
+ if (keepingTrackOf) {
+ baritone.getWorldProvider().ifWorldLoaded(worldData -> {
+ final Level world = baritone.getPlayerContext().world();
+ ChunkPos pos = event.getChunkPos();
+ worldData.getCachedWorld().queueForPacking(world.getChunk(pos.x, pos.z));
+ });
+ }
+ }
+
+ listeners.forEach(l -> l.onBlockChange(event));
+ }
+
@Override
public final void onRenderPass(RenderEvent event) {
listeners.forEach(l -> l.onRenderPass(event));
@@ -114,7 +140,7 @@ public final class GameEventHandler implements IEventBus, Helper {
if (event.getState() == EventState.POST) {
cache.closeWorld();
if (event.getWorld() != null) {
- cache.initWorld(event.getWorld().dimension(), event.getWorld().dimensionType());
+ cache.initWorld(event.getWorld());
}
}
diff --git a/src/main/java/baritone/pathing/movement/CalculationContext.java b/src/main/java/baritone/pathing/movement/CalculationContext.java
index c1cc0daf5..64aca2ceb 100644
--- a/src/main/java/baritone/pathing/movement/CalculationContext.java
+++ b/src/main/java/baritone/pathing/movement/CalculationContext.java
@@ -28,8 +28,8 @@ import baritone.utils.pathing.BetterWorldBorder;
import net.minecraft.client.player.LocalPlayer;
import net.minecraft.core.BlockPos;
import net.minecraft.world.entity.player.Inventory;
-import net.minecraft.world.item.Items;
import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
import net.minecraft.world.item.enchantment.EnchantmentHelper;
import net.minecraft.world.item.enchantment.Enchantments;
import net.minecraft.world.level.Level;
@@ -66,11 +66,13 @@ public class CalculationContext {
public final boolean allowJumpAt256;
public final boolean allowParkourAscend;
public final boolean assumeWalkOnWater;
+ public boolean allowFallIntoLava;
public final int frostWalker;
public final boolean allowDiagonalDescend;
public final boolean allowDiagonalAscend;
public final boolean allowDownward;
- public final int maxFallHeightNoWater;
+ public int minFallHeight;
+ public int maxFallHeightNoWater;
public final int maxFallHeightBucket;
public final double waterWalkSpeed;
public final double breakBlockAdditionalCost;
@@ -91,8 +93,8 @@ public class CalculationContext {
this.baritone = baritone;
LocalPlayer player = baritone.getPlayerContext().player();
this.world = baritone.getPlayerContext().world();
- this.worldData = (WorldData) baritone.getWorldProvider().getCurrentWorld();
- this.bsi = new BlockStateInterface(world, worldData, forUseOnAnotherThread);
+ this.worldData = (WorldData) baritone.getPlayerContext().worldData();
+ this.bsi = new BlockStateInterface(baritone.getPlayerContext(), forUseOnAnotherThread);
this.toolSet = new ToolSet(player);
this.hasThrowaway = Baritone.settings().allowPlace.value && ((Baritone) baritone).getInventoryBehavior().hasGenericThrowaway();
this.hasWaterBucket = Baritone.settings().allowWaterBucketFall.value && Inventory.isHotbarSlot(player.getInventory().findSlotMatchingItem(STACK_BUCKET_WATER)) && world.dimension() != Level.NETHER;
@@ -105,10 +107,12 @@ public class CalculationContext {
this.allowJumpAt256 = Baritone.settings().allowJumpAt256.value;
this.allowParkourAscend = Baritone.settings().allowParkourAscend.value;
this.assumeWalkOnWater = Baritone.settings().assumeWalkOnWater.value;
+ this.allowFallIntoLava = false; // Super secret internal setting for ElytraBehavior
this.frostWalker = EnchantmentHelper.getEnchantmentLevel(Enchantments.FROST_WALKER, baritone.getPlayerContext().player());
this.allowDiagonalDescend = Baritone.settings().allowDiagonalDescend.value;
this.allowDiagonalAscend = Baritone.settings().allowDiagonalAscend.value;
this.allowDownward = Baritone.settings().allowDownward.value;
+ this.minFallHeight = 3; // Minimum fall height used by MovementFall
this.maxFallHeightNoWater = Baritone.settings().maxFallHeightNoWater.value;
this.maxFallHeightBucket = Baritone.settings().maxFallHeightBucket.value;
int depth = EnchantmentHelper.getDepthStrider(player);
diff --git a/src/main/java/baritone/pathing/movement/Movement.java b/src/main/java/baritone/pathing/movement/Movement.java
index d319cea62..739c8ee89 100644
--- a/src/main/java/baritone/pathing/movement/Movement.java
+++ b/src/main/java/baritone/pathing/movement/Movement.java
@@ -162,7 +162,7 @@ public abstract class Movement implements IMovement, MovementHelper {
if (!MovementHelper.canWalkThrough(ctx, blockPos)) { // can't break air, so don't try
somethingInTheWay = true;
MovementHelper.switchToBestToolFor(ctx, BlockStateInterface.get(ctx, blockPos));
- Optional reachable = RotationUtils.reachable(ctx.player(), blockPos, ctx.playerController().getBlockReachDistance());
+ Optional reachable = RotationUtils.reachable(ctx, blockPos, ctx.playerController().getBlockReachDistance());
if (reachable.isPresent()) {
Rotation rotTowardsBlock = reachable.get();
state.setTarget(new MovementState.MovementTarget(rotTowardsBlock, true));
diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index 2c642b0e3..f5c928cd4 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -650,9 +650,9 @@ public interface MovementHelper extends ActionCosts, Helper {
static void moveTowards(IPlayerContext ctx, MovementState state, BlockPos pos) {
state.setTarget(new MovementTarget(
- new Rotation(RotationUtils.calcRotationFromVec3d(ctx.playerHead(),
+ RotationUtils.calcRotationFromVec3d(ctx.playerHead(),
VecUtils.getBlockPosCenter(pos),
- ctx.playerRotations()).getYaw(), ctx.player().getXRot()),
+ ctx.playerRotations()).withPitch(ctx.playerRotations().getPitch()),
false
)).setInput(Input.MOVE_FORWARD, true);
}
@@ -759,7 +759,8 @@ public interface MovementHelper extends ActionCosts, Helper {
double faceY = (placeAt.getY() + against1.getY() + 0.5D) * 0.5D;
double faceZ = (placeAt.getZ() + against1.getZ() + 1.0D) * 0.5D;
Rotation place = RotationUtils.calcRotationFromVec3d(wouldSneak ? RayTraceUtils.inferSneakingEyePosition(ctx.player()) : ctx.playerHead(), new Vec3(faceX, faceY, faceZ), ctx.playerRotations());
- HitResult res = RayTraceUtils.rayTraceTowards(ctx.player(), place, ctx.playerController().getBlockReachDistance(), wouldSneak);
+ Rotation actual = baritone.getLookBehavior().getAimProcessor().peekRotation(place);
+ HitResult res = RayTraceUtils.rayTraceTowards(ctx.player(), actual, ctx.playerController().getBlockReachDistance(), wouldSneak);
if (res != null && res.getType() == HitResult.Type.BLOCK && ((BlockHitResult) res).getBlockPos().equals(against1) && ((BlockHitResult) res).getBlockPos().relative(((BlockHitResult) res).getDirection()).equals(placeAt)) {
state.setTarget(new MovementTarget(place, true));
found = true;
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDescend.java b/src/main/java/baritone/pathing/movement/movements/MovementDescend.java
index ec069ae4f..07d6d7d01 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementDescend.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementDescend.java
@@ -20,7 +20,6 @@ package baritone.pathing.movement.movements;
import baritone.api.IBaritone;
import baritone.api.pathing.movement.MovementStatus;
import baritone.api.utils.BetterBlockPos;
-import baritone.api.utils.Rotation;
import baritone.api.utils.RotationUtils;
import baritone.api.utils.input.Input;
import baritone.pathing.movement.CalculationContext;
@@ -30,8 +29,6 @@ import baritone.pathing.movement.MovementState;
import baritone.utils.BlockStateInterface;
import baritone.utils.pathing.MutableMoveResult;
import com.google.common.collect.ImmutableSet;
-import java.util.Set;
-import net.minecraft.client.player.LocalPlayer;
import net.minecraft.core.BlockPos;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.Blocks;
@@ -39,6 +36,8 @@ import net.minecraft.world.level.block.FallingBlock;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.phys.Vec3;
+import java.util.Set;
+
public class MovementDescend extends Movement {
private int numTicks = 0;
@@ -153,10 +152,11 @@ public class MovementDescend extends Movement {
// this check prevents it from getting the block at y=-1 and crashing
return false;
}
+ boolean reachedMinimum = fallHeight >= context.minFallHeight;
BlockState ontoBlock = context.get(destX, newY, destZ);
int unprotectedFallHeight = fallHeight - (y - effectiveStartHeight); // equal to fallHeight - y + effectiveFallHeight, which is equal to -newY + effectiveFallHeight, which is equal to effectiveFallHeight - newY
double tentativeCost = WALK_OFF_BLOCK_COST + FALL_N_BLOCKS_COST[unprotectedFallHeight] + frontBreak + costSoFar;
- if (MovementHelper.isWater(ontoBlock)) {
+ if (reachedMinimum && MovementHelper.isWater(ontoBlock)) {
if (!MovementHelper.canWalkThrough(context, destX, newY, destZ, ontoBlock)) {
return false;
}
@@ -177,6 +177,14 @@ public class MovementDescend extends Movement {
res.cost = tentativeCost;// TODO incorporate water swim up cost?
return false;
}
+ if (reachedMinimum && context.allowFallIntoLava && MovementHelper.isLava(ontoBlock)) {
+ // found a fall into lava
+ res.x = destX;
+ res.y = newY;
+ res.z = destZ;
+ res.cost = tentativeCost;
+ return false;
+ }
if (unprotectedFallHeight <= 11 && (ontoBlock.getBlock() == Blocks.VINE || ontoBlock.getBlock() == Blocks.LADDER)) {
// if fall height is greater than or equal to 11, we don't actually grab on to vines or ladders. the more you know
// this effectively "resets" our falling speed
@@ -194,7 +202,7 @@ public class MovementDescend extends Movement {
if (MovementHelper.isBottomSlab(ontoBlock)) {
return false; // falling onto a half slab is really glitchy, and can cause more fall damage than we'd expect
}
- if (unprotectedFallHeight <= context.maxFallHeightNoWater + 1) {
+ if (reachedMinimum && unprotectedFallHeight <= context.maxFallHeightNoWater + 1) {
// fallHeight = 4 means onto.up() is 3 blocks down, which is the max
res.x = destX;
res.y = newY + 1;
@@ -202,7 +210,7 @@ public class MovementDescend extends Movement {
res.cost = tentativeCost;
return false;
}
- if (context.hasWaterBucket && unprotectedFallHeight <= context.maxFallHeightBucket + 1) {
+ if (reachedMinimum && context.hasWaterBucket && unprotectedFallHeight <= context.maxFallHeightBucket + 1) {
res.x = destX;
res.y = newY + 1;// this is the block we're falling onto, so dest is +1
res.z = destZ;
@@ -233,11 +241,10 @@ public class MovementDescend extends Movement {
if (safeMode()) {
double destX = (src.getX() + 0.5) * 0.17 + (dest.getX() + 0.5) * 0.83;
double destZ = (src.getZ() + 0.5) * 0.17 + (dest.getZ() + 0.5) * 0.83;
- LocalPlayer player = ctx.player();
state.setTarget(new MovementState.MovementTarget(
- new Rotation(RotationUtils.calcRotationFromVec3d(ctx.playerHead(),
+ RotationUtils.calcRotationFromVec3d(ctx.playerHead(),
new Vec3(destX, dest.getY(), destZ),
- new Rotation(player.getYRot(), player.getXRot())).getYaw(), player.getXRot()),
+ ctx.playerRotations()).withPitch(ctx.playerRotations().getPitch()),
false
)).setInput(Input.MOVE_FORWARD, true);
return state;
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementPillar.java b/src/main/java/baritone/pathing/movement/movements/MovementPillar.java
index 50ecf930c..18c105d2b 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementPillar.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementPillar.java
@@ -32,14 +32,7 @@ import baritone.pathing.movement.MovementState;
import baritone.utils.BlockStateInterface;
import com.google.common.collect.ImmutableSet;
import net.minecraft.core.BlockPos;
-import net.minecraft.world.level.block.AirBlock;
-import net.minecraft.world.level.block.Block;
-import net.minecraft.world.level.block.Blocks;
-import net.minecraft.world.level.block.CarpetBlock;
-import net.minecraft.world.level.block.FallingBlock;
-import net.minecraft.world.level.block.FenceGateBlock;
-import net.minecraft.world.level.block.LadderBlock;
-import net.minecraft.world.level.block.SlabBlock;
+import net.minecraft.world.level.block.*;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.block.state.properties.SlabType;
import net.minecraft.world.phys.Vec3;
@@ -196,9 +189,9 @@ public class MovementPillar extends Movement {
boolean vine = fromDown.getBlock() == Blocks.VINE;
Rotation rotation = RotationUtils.calcRotationFromVec3d(ctx.playerHead(),
VecUtils.getBlockPosCenter(positionToPlace),
- new Rotation(ctx.player().getYRot(), ctx.player().getXRot()));
+ ctx.playerRotations());
if (!ladder) {
- state.setTarget(new MovementState.MovementTarget(new Rotation(ctx.player().getYRot(), rotation.getPitch()), true));
+ state.setTarget(new MovementState.MovementTarget(ctx.playerRotations().withPitch(rotation.getPitch()), true));
}
boolean blockIsThere = MovementHelper.canWalkOn(ctx, src) || ladder;
@@ -257,7 +250,7 @@ public class MovementPillar extends Movement {
Block fr = frState.getBlock();
// TODO: Evaluate usage of getMaterial().isReplaceable()
if (!(fr instanceof AirBlock || frState.canBeReplaced())) {
- RotationUtils.reachable(ctx.player(), src, ctx.playerController().getBlockReachDistance())
+ RotationUtils.reachable(ctx, src, ctx.playerController().getBlockReachDistance())
.map(rot -> new MovementState.MovementTarget(rot, true))
.ifPresent(state::setTarget);
state.setInput(Input.JUMP, false); // breaking is like 5x slower when you're jumping
diff --git a/src/main/java/baritone/process/BuilderProcess.java b/src/main/java/baritone/process/BuilderProcess.java
index 62c9a3da0..c484140fc 100644
--- a/src/main/java/baritone/process/BuilderProcess.java
+++ b/src/main/java/baritone/process/BuilderProcess.java
@@ -30,10 +30,7 @@ import baritone.api.schematic.ISchematic;
import baritone.api.schematic.IStaticSchematic;
import baritone.api.schematic.SubstituteSchematic;
import baritone.api.schematic.format.ISchematicFormat;
-import baritone.api.utils.BetterBlockPos;
-import baritone.api.utils.RayTraceUtils;
-import baritone.api.utils.Rotation;
-import baritone.api.utils.RotationUtils;
+import baritone.api.utils.*;
import baritone.api.utils.input.Input;
import baritone.pathing.movement.CalculationContext;
import baritone.pathing.movement.Movement;
@@ -60,7 +57,14 @@ import net.minecraft.world.item.BlockItem;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.item.context.BlockPlaceContext;
import net.minecraft.world.item.context.UseOnContext;
-import net.minecraft.world.level.block.*;
+import net.minecraft.world.level.block.AirBlock;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.HorizontalDirectionalBlock;
+import net.minecraft.world.level.block.LiquidBlock;
+import net.minecraft.world.level.block.PipeBlock;
+import net.minecraft.world.level.block.RotatedPillarBlock;
+import net.minecraft.world.level.block.StairBlock;
+import net.minecraft.world.level.block.TrapDoorBlock;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.block.state.properties.Property;
import net.minecraft.world.phys.AABB;
@@ -164,7 +168,6 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
if (!format.isPresent()) {
return false;
}
-
ISchematic parsed;
try {
parsed = format.get().parse(new FileInputStream(schematic));
@@ -172,20 +175,22 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
e.printStackTrace();
return false;
}
-
- if (Baritone.settings().mapArtMode.value) {
- parsed = new MapArtSchematic((IStaticSchematic) parsed);
- }
-
- if (Baritone.settings().buildOnlySelection.value) {
- parsed = new SelectionSchematic(parsed, origin, baritone.getSelectionManager().getSelections());
- }
-
-
+ parsed = applyMapArtAndSelection(origin, (IStaticSchematic) parsed);
build(name, parsed, origin);
return true;
}
+ private ISchematic applyMapArtAndSelection(Vec3i origin, IStaticSchematic parsed) {
+ ISchematic schematic = parsed;
+ if (Baritone.settings().mapArtMode.value) {
+ schematic = new MapArtSchematic(parsed);
+ }
+ if (Baritone.settings().buildOnlySelection.value) {
+ schematic = new SelectionSchematic(schematic, origin, baritone.getSelectionManager().getSelections());
+ }
+ return schematic;
+ }
+
@Override
public void buildOpenSchematic() {
if (SchematicaHelper.isSchematicaPresent()) {
@@ -219,7 +224,8 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
try {
LitematicaSchematic schematic1 = new LitematicaSchematic(NbtIo.readCompressed(Files.newInputStream(LitematicaHelper.getSchematicFile(i).toPath())), false);
Vec3i correctedOrigin = LitematicaHelper.getCorrectedOrigin(schematic1, i);
- LitematicaSchematic schematic2 = LitematicaHelper.blackMagicFuckery(schematic1, i);
+ ISchematic schematic2 = LitematicaHelper.blackMagicFuckery(schematic1, i);
+ schematic2 = applyMapArtAndSelection(origin, (IStaticSchematic) schematic2);
build(name, schematic2, correctedOrigin);
} catch (Exception e) {
logDirect("Schematic File could not be loaded.");
@@ -283,7 +289,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
BlockState curr = bcc.bsi.get0(x, y, z);
if (!(curr.getBlock() instanceof AirBlock) && !(curr.getBlock() == Blocks.WATER || curr.getBlock() == Blocks.LAVA) && !valid(curr, desired, false)) {
BetterBlockPos pos = new BetterBlockPos(x, y, z);
- Optional rot = RotationUtils.reachable(ctx.player(), pos, ctx.playerController().getBlockReachDistance());
+ Optional rot = RotationUtils.reachable(ctx, pos, ctx.playerController().getBlockReachDistance());
if (rot.isPresent()) {
return Optional.of(new Tuple<>(pos, rot.get()));
}
@@ -362,9 +368,10 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
double placeY = placeAgainstPos.y + aabb.minY * placementMultiplier.y + aabb.maxY * (1 - placementMultiplier.y);
double placeZ = placeAgainstPos.z + aabb.minZ * placementMultiplier.z + aabb.maxZ * (1 - placementMultiplier.z);
Rotation rot = RotationUtils.calcRotationFromVec3d(RayTraceUtils.inferSneakingEyePosition(ctx.player()), new Vec3(placeX, placeY, placeZ), ctx.playerRotations());
- HitResult result = RayTraceUtils.rayTraceTowards(ctx.player(), rot, ctx.playerController().getBlockReachDistance(), true);
+ Rotation actualRot = baritone.getLookBehavior().getAimProcessor().peekRotation(rot);
+ HitResult result = RayTraceUtils.rayTraceTowards(ctx.player(), actualRot, ctx.playerController().getBlockReachDistance(), true);
if (result != null && result.getType() == HitResult.Type.BLOCK && ((BlockHitResult) result).getBlockPos().equals(placeAgainstPos) && ((BlockHitResult) result).getDirection() == against.getOpposite()) {
- OptionalInt hotbar = hasAnyItemThatWouldPlace(toPlace, result, rot);
+ OptionalInt hotbar = hasAnyItemThatWouldPlace(toPlace, result, actualRot);
if (hotbar.isPresent()) {
return Optional.of(new Placement(hotbar.getAsInt(), placeAgainstPos, against.getOpposite(), rot));
}
@@ -574,7 +581,10 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
for (int i = 9; i < 36; i++) {
for (BlockState desired : noValidHotbarOption) {
if (valid(approxPlaceable.get(i), desired, true)) {
- baritone.getInventoryBehavior().attemptToPutOnHotbar(i, usefulSlots::contains);
+ if (!baritone.getInventoryBehavior().attemptToPutOnHotbar(i, usefulSlots::contains)) {
+ // awaiting inventory move, so pause
+ return new PathingCommand(null, PathingCommandType.REQUEST_PAUSE);
+ }
break outer;
}
}
@@ -700,7 +710,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
incorrectPositions.forEach(pos -> {
BlockState state = bcc.bsi.get0(pos);
if (state.getBlock() instanceof AirBlock) {
- if (approxPlaceable.contains(bcc.getSchematic(pos.x, pos.y, pos.z, state))) {
+ if (containsBlockState(approxPlaceable, bcc.getSchematic(pos.x, pos.y, pos.z, state))) {
placeable.add(pos);
} else {
BlockState desired = bcc.getSchematic(pos.x, pos.y, pos.z, state);
@@ -773,6 +783,28 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
return primary.heuristic(x, y, z);
}
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+
+ JankyGoalComposite goal = (JankyGoalComposite) o;
+ return Objects.equals(primary, goal.primary)
+ && Objects.equals(fallback, goal.fallback);
+ }
+
+ @Override
+ public int hashCode() {
+ int hash = -1701079641;
+ hash = hash * 1196141026 + primary.hashCode();
+ hash = hash * -80327868 + fallback.hashCode();
+ return hash;
+ }
+
@Override
public String toString() {
return "JankyComposite Primary: " + primary + " Fallback: " + fallback;
@@ -794,6 +826,21 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
// but any other adjacent works for breaking, including inside or below
return super.isInGoal(x, y, z);
}
+
+ @Override
+ public String toString() {
+ return String.format(
+ "GoalBreak{x=%s,y=%s,z=%s}",
+ SettingsUtil.maybeCensor(x),
+ SettingsUtil.maybeCensor(y),
+ SettingsUtil.maybeCensor(z)
+ );
+ }
+
+ @Override
+ public int hashCode() {
+ return super.hashCode() * 1636324008;
+ }
}
private Goal placementGoal(BlockPos pos, BuilderCalculationContext bcc) {
@@ -837,6 +884,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
this.allowSameLevel = allowSameLevel;
}
+ @Override
public boolean isInGoal(int x, int y, int z) {
if (x == this.x && y == this.y && z == this.z) {
return false;
@@ -853,10 +901,41 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
return super.isInGoal(x, y, z);
}
+ @Override
public double heuristic(int x, int y, int z) {
// prioritize lower y coordinates
return this.y * 100 + super.heuristic(x, y, z);
}
+
+ @Override
+ public boolean equals(Object o) {
+ if (!super.equals(o)) {
+ return false;
+ }
+
+ GoalAdjacent goal = (GoalAdjacent) o;
+ return allowSameLevel == goal.allowSameLevel
+ && Objects.equals(no, goal.no);
+ }
+
+ @Override
+ public int hashCode() {
+ int hash = 806368046;
+ hash = hash * 1412661222 + super.hashCode();
+ hash = hash * 1730799370 + (int) BetterBlockPos.longHash(no.getX(), no.getY(), no.getZ());
+ hash = hash * 260592149 + (allowSameLevel ? -1314802005 : 1565710265);
+ return hash;
+ }
+
+ @Override
+ public String toString() {
+ return String.format(
+ "GoalAdjacent{x=%s,y=%s,z=%s}",
+ SettingsUtil.maybeCensor(x),
+ SettingsUtil.maybeCensor(y),
+ SettingsUtil.maybeCensor(z)
+ );
+ }
}
public static class GoalPlace extends GoalBlock {
@@ -865,10 +944,26 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
super(placeAt.above());
}
+ @Override
public double heuristic(int x, int y, int z) {
// prioritize lower y coordinates
return this.y * 100 + super.heuristic(x, y, z);
}
+
+ @Override
+ public int hashCode() {
+ return super.hashCode() * 1910811835;
+ }
+
+ @Override
+ public String toString() {
+ return String.format(
+ "GoalPlace{x=%s,y=%s,z=%s}",
+ SettingsUtil.maybeCensor(x),
+ SettingsUtil.maybeCensor(y),
+ SettingsUtil.maybeCensor(z)
+ );
+ }
}
@Override
@@ -943,6 +1038,15 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
return true;
}
+ private boolean containsBlockState(Collection states, BlockState state) {
+ for (BlockState testee : states) {
+ if (sameBlockstate(testee, state)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
private boolean valid(BlockState current, BlockState desired, boolean itemVerify) {
if (desired == null) {
return true;
diff --git a/src/main/java/baritone/process/CustomGoalProcess.java b/src/main/java/baritone/process/CustomGoalProcess.java
index 3ee3e7b7c..d0dca9cbf 100644
--- a/src/main/java/baritone/process/CustomGoalProcess.java
+++ b/src/main/java/baritone/process/CustomGoalProcess.java
@@ -36,6 +36,11 @@ public final class CustomGoalProcess extends BaritoneProcessHelper implements IC
*/
private Goal goal;
+ /**
+ * The most recent goal. Not invalidated upon {@link #onLostControl()}
+ */
+ private Goal mostRecentGoal;
+
/**
* The current process state.
*
@@ -50,6 +55,10 @@ public final class CustomGoalProcess extends BaritoneProcessHelper implements IC
@Override
public void setGoal(Goal goal) {
this.goal = goal;
+ this.mostRecentGoal = goal;
+ if (baritone.getElytraProcess().isActive()) {
+ baritone.getElytraProcess().pathTo(goal);
+ }
if (this.state == State.NONE) {
this.state = State.GOAL_SET;
}
@@ -68,6 +77,11 @@ public final class CustomGoalProcess extends BaritoneProcessHelper implements IC
return this.goal;
}
+ @Override
+ public Goal mostRecentGoal() {
+ return this.mostRecentGoal;
+ }
+
@Override
public boolean isActive() {
return this.state != State.NONE;
diff --git a/src/main/java/baritone/process/ElytraProcess.java b/src/main/java/baritone/process/ElytraProcess.java
new file mode 100644
index 000000000..da5be3398
--- /dev/null
+++ b/src/main/java/baritone/process/ElytraProcess.java
@@ -0,0 +1,571 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.process;
+
+import baritone.Baritone;
+import baritone.api.IBaritone;
+import baritone.api.event.events.*;
+import baritone.api.event.events.type.EventState;
+import baritone.api.event.listener.AbstractGameEventListener;
+import baritone.api.pathing.goals.Goal;
+import baritone.api.pathing.goals.GoalBlock;
+import baritone.api.pathing.goals.GoalXZ;
+import baritone.api.pathing.goals.GoalYLevel;
+import baritone.api.pathing.movement.IMovement;
+import baritone.api.pathing.path.IPathExecutor;
+import baritone.api.process.IBaritoneProcess;
+import baritone.api.process.IElytraProcess;
+import baritone.api.process.PathingCommand;
+import baritone.api.process.PathingCommandType;
+import baritone.api.utils.BetterBlockPos;
+import baritone.api.utils.Rotation;
+import baritone.api.utils.RotationUtils;
+import baritone.api.utils.input.Input;
+import baritone.pathing.movement.CalculationContext;
+import baritone.pathing.movement.movements.MovementFall;
+import baritone.process.elytra.ElytraBehavior;
+import baritone.process.elytra.NetherPathfinderContext;
+import baritone.process.elytra.NullElytraProcess;
+import baritone.utils.BaritoneProcessHelper;
+import baritone.utils.PathingCommandContext;
+import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.NonNullList;
+import net.minecraft.world.entity.EquipmentSlot;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.AirBlock;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.Vec3;
+
+import java.util.*;
+
+import static baritone.api.pathing.movement.ActionCosts.COST_INF;
+
+public class ElytraProcess extends BaritoneProcessHelper implements IBaritoneProcess, IElytraProcess, AbstractGameEventListener {
+ public State state;
+ private boolean goingToLandingSpot;
+ private BetterBlockPos landingSpot;
+ private boolean reachedGoal; // this basically just prevents potential notification spam
+ private Goal goal;
+ private ElytraBehavior behavior;
+ private boolean predictingTerrain;
+
+ private ElytraProcess(Baritone baritone) {
+ super(baritone);
+ baritone.getGameEventHandler().registerEventListener(this);
+ }
+
+ public static T create(final Baritone baritone) {
+ return (T) (NetherPathfinderContext.isSupported()
+ ? new ElytraProcess(baritone)
+ : new NullElytraProcess(baritone));
+ }
+
+ @Override
+ public boolean isActive() {
+ return this.behavior != null;
+ }
+
+ @Override
+ public void resetState() {
+ BlockPos destination = this.currentDestination();
+ this.onLostControl();
+ if (destination != null) {
+ this.pathTo(destination);
+ this.repackChunks();
+ }
+ }
+
+ private static final String AUTO_JUMP_FAILURE_MSG = "Failed to compute a walking path to a spot to jump off from. Consider starting from a higher location, near an overhang. Or, you can disable elytraAutoJump and just manually begin gliding.";
+
+ @Override
+ public PathingCommand onTick(boolean calcFailed, boolean isSafeToCancel) {
+ final long seedSetting = Baritone.settings().elytraNetherSeed.value;
+ if (seedSetting != this.behavior.context.getSeed()) {
+ logDirect("Nether seed changed, recalculating path");
+ this.resetState();
+ }
+ if (predictingTerrain != Baritone.settings().elytraPredictTerrain.value) {
+ logDirect("elytraPredictTerrain setting changed, recalculating path");
+ predictingTerrain = Baritone.settings().elytraPredictTerrain.value;
+ this.resetState();
+ }
+
+ this.behavior.onTick();
+
+ if (calcFailed) {
+ onLostControl();
+ logDirect(AUTO_JUMP_FAILURE_MSG);
+ return new PathingCommand(null, PathingCommandType.CANCEL_AND_SET_GOAL);
+ }
+
+ boolean safetyLanding = false;
+ if (ctx.player().isFallFlying() && shouldLandForSafety()) {
+ if (Baritone.settings().elytraAllowEmergencyLand.value) {
+ logDirect("Emergency landing - almost out of elytra durability or fireworks");
+ safetyLanding = true;
+ } else {
+ logDirect("almost out of elytra durability or fireworks, but I'm going to continue since elytraAllowEmergencyLand is false");
+ }
+ }
+ if (ctx.player().isFallFlying() && this.state != State.LANDING && (this.behavior.pathManager.isComplete() || safetyLanding)) {
+ final BetterBlockPos last = this.behavior.pathManager.path.getLast();
+ if (last != null && (ctx.player().position().distanceToSqr(last.getCenter()) < (48 * 48) || safetyLanding) && (!goingToLandingSpot || (safetyLanding && this.landingSpot == null))) {
+ logDirect("Path complete, picking a nearby safe landing spot...");
+ BetterBlockPos landingSpot = findSafeLandingSpot(ctx.playerFeet());
+ // if this fails we will just keep orbiting the last node until we run out of rockets or the user intervenes
+ if (landingSpot != null) {
+ this.pathTo0(landingSpot, true);
+ this.landingSpot = landingSpot;
+ }
+ this.goingToLandingSpot = true;
+ }
+
+ if (last != null && ctx.player().position().distanceToSqr(last.getCenter()) < 1) {
+ if (Baritone.settings().notificationOnPathComplete.value && !reachedGoal) {
+ logNotification("Pathing complete", false);
+ }
+ if (Baritone.settings().disconnectOnArrival.value && !reachedGoal) {
+ // don't be active when the user logs back in
+ this.onLostControl();
+ ctx.world().disconnect();
+ return new PathingCommand(null, PathingCommandType.CANCEL_AND_SET_GOAL);
+ }
+ reachedGoal = true;
+
+ // we are goingToLandingSpot and we are in the last node of the path
+ if (this.goingToLandingSpot) {
+ this.state = State.LANDING;
+ logDirect("Above the landing spot, landing...");
+ }
+ }
+ }
+
+ if (this.state == State.LANDING) {
+ final BetterBlockPos endPos = this.landingSpot != null ? this.landingSpot : behavior.pathManager.path.getLast();
+ if (ctx.player().isFallFlying() && endPos != null) {
+ Vec3 from = ctx.player().position();
+ Vec3 to = new Vec3(((double) endPos.x) + 0.5, from.y, ((double) endPos.z) + 0.5);
+ Rotation rotation = RotationUtils.calcRotationFromVec3d(from, to, ctx.playerRotations());
+ baritone.getLookBehavior().updateTarget(new Rotation(rotation.getYaw(), 0), false); // this will be overwritten, probably, by behavior tick
+
+ if (ctx.player().position().y < endPos.y - LANDING_COLUMN_HEIGHT) {
+ logDirect("bad landing spot, trying again...");
+ landingSpotIsBad(endPos);
+ }
+ }
+ }
+
+ if (ctx.player().isFallFlying()) {
+ behavior.landingMode = this.state == State.LANDING;
+ this.goal = null;
+ baritone.getInputOverrideHandler().clearAllKeys();
+ behavior.tick();
+ return new PathingCommand(null, PathingCommandType.CANCEL_AND_SET_GOAL);
+ } else if (this.state == State.LANDING) {
+ if (ctx.playerMotion().multiply(1, 0, 1).length() > 0.001) {
+ logDirect("Landed, but still moving, waiting for velocity to die down... ");
+ baritone.getInputOverrideHandler().setInputForceState(Input.SNEAK, true);
+ return new PathingCommand(null, PathingCommandType.REQUEST_PAUSE);
+ }
+ logDirect("Done :)");
+ baritone.getInputOverrideHandler().clearAllKeys();
+ this.onLostControl();
+ return new PathingCommand(null, PathingCommandType.REQUEST_PAUSE);
+ }
+
+ if (this.state == State.FLYING || this.state == State.START_FLYING) {
+ this.state = ctx.player().onGround() && Baritone.settings().elytraAutoJump.value
+ ? State.LOCATE_JUMP
+ : State.START_FLYING;
+ }
+
+ if (this.state == State.LOCATE_JUMP) {
+ if (shouldLandForSafety()) {
+ logDirect("Not taking off, because elytra durability or fireworks are so low that I would immediately emergency land anyway.");
+ onLostControl();
+ return new PathingCommand(null, PathingCommandType.CANCEL_AND_SET_GOAL);
+ }
+ if (this.goal == null) {
+ this.goal = new GoalYLevel(31);
+ }
+ final IPathExecutor executor = baritone.getPathingBehavior().getCurrent();
+ if (executor != null && executor.getPath().getGoal() == this.goal) {
+ final IMovement fall = executor.getPath().movements().stream()
+ .filter(movement -> movement instanceof MovementFall)
+ .findFirst().orElse(null);
+
+ if (fall != null) {
+ final BetterBlockPos from = new BetterBlockPos(
+ (fall.getSrc().x + fall.getDest().x) / 2,
+ (fall.getSrc().y + fall.getDest().y) / 2,
+ (fall.getSrc().z + fall.getDest().z) / 2
+ );
+ behavior.pathManager.pathToDestination(from).whenComplete((result, ex) -> {
+ if (ex == null) {
+ this.state = State.GET_TO_JUMP;
+ return;
+ }
+ onLostControl();
+ });
+ this.state = State.PAUSE;
+ } else {
+ onLostControl();
+ logDirect(AUTO_JUMP_FAILURE_MSG);
+ return new PathingCommand(null, PathingCommandType.CANCEL_AND_SET_GOAL);
+ }
+ }
+ return new PathingCommandContext(this.goal, PathingCommandType.SET_GOAL_AND_PAUSE, new WalkOffCalculationContext(baritone));
+ }
+
+ // yucky
+ if (this.state == State.PAUSE) {
+ return new PathingCommand(null, PathingCommandType.REQUEST_PAUSE);
+ }
+
+ if (this.state == State.GET_TO_JUMP) {
+ final IPathExecutor executor = baritone.getPathingBehavior().getCurrent();
+ final boolean canStartFlying = ctx.player().fallDistance > 1.0f
+ && !isSafeToCancel
+ && executor != null
+ && executor.getPath().movements().get(executor.getPosition()) instanceof MovementFall;
+
+ if (canStartFlying) {
+ this.state = State.START_FLYING;
+ } else {
+ return new PathingCommand(null, PathingCommandType.SET_GOAL_AND_PATH);
+ }
+ }
+
+ if (this.state == State.START_FLYING) {
+ if (!isSafeToCancel) {
+ // owned
+ baritone.getPathingBehavior().secretInternalSegmentCancel();
+ }
+ baritone.getInputOverrideHandler().clearAllKeys();
+ if (ctx.player().fallDistance > 1.0f) {
+ baritone.getInputOverrideHandler().setInputForceState(Input.JUMP, true);
+ }
+ }
+ return new PathingCommand(null, PathingCommandType.CANCEL_AND_SET_GOAL);
+ }
+
+ public void landingSpotIsBad(BetterBlockPos endPos) {
+ badLandingSpots.add(endPos);
+ goingToLandingSpot = false;
+ this.landingSpot = null;
+ this.state = State.FLYING;
+ }
+
+ @Override
+ public void onLostControl() {
+ this.goal = null;
+ this.goingToLandingSpot = false;
+ this.landingSpot = null;
+ this.reachedGoal = false;
+ this.state = State.START_FLYING; // TODO: null state?
+ destroyBehaviorAsync();
+ }
+
+ private void destroyBehaviorAsync() {
+ ElytraBehavior behavior = this.behavior;
+ if (behavior != null) {
+ this.behavior = null;
+ Baritone.getExecutor().execute(behavior::destroy);
+ }
+ }
+
+ @Override
+ public double priority() {
+ return 0; // higher priority than CustomGoalProcess
+ }
+
+ @Override
+ public String displayName0() {
+ return "Elytra - " + this.state.description;
+ }
+
+ @Override
+ public void repackChunks() {
+ if (this.behavior != null) {
+ this.behavior.repackChunks();
+ }
+ }
+
+ @Override
+ public BlockPos currentDestination() {
+ return this.behavior != null ? this.behavior.destination : null;
+ }
+
+ @Override
+ public void pathTo(BlockPos destination) {
+ this.pathTo0(destination, false);
+ }
+
+ private void pathTo0(BlockPos destination, boolean appendDestination) {
+ if (ctx.player() == null || ctx.player().level().dimension() != Level.NETHER) {
+ return;
+ }
+ this.onLostControl();
+ this.predictingTerrain = Baritone.settings().elytraPredictTerrain.value;
+ this.behavior = new ElytraBehavior(this.baritone, this, destination, appendDestination);
+ if (ctx.world() != null) {
+ this.behavior.repackChunks();
+ }
+ this.behavior.pathTo();
+ }
+
+ @Override
+ public void pathTo(Goal iGoal) {
+ final int x;
+ final int y;
+ final int z;
+ if (iGoal instanceof GoalXZ) {
+ GoalXZ goal = (GoalXZ) iGoal;
+ x = goal.getX();
+ y = 64;
+ z = goal.getZ();
+ } else if (iGoal instanceof GoalBlock) {
+ GoalBlock goal = (GoalBlock) iGoal;
+ x = goal.x;
+ y = goal.y;
+ z = goal.z;
+ } else {
+ throw new IllegalArgumentException("The goal must be a GoalXZ or GoalBlock");
+ }
+ if (y <= 0 || y >= 128) {
+ throw new IllegalArgumentException("The y of the goal is not between 0 and 128");
+ }
+ this.pathTo(new BlockPos(x, y, z));
+ }
+
+ private boolean shouldLandForSafety() {
+ ItemStack chest = ctx.player().getItemBySlot(EquipmentSlot.CHEST);
+ if (chest.getItem() != Items.ELYTRA || chest.getItem().getMaxDamage() - chest.getDamageValue() < Baritone.settings().elytraMinimumDurability.value) {
+ // elytrabehavior replaces when durability <= minimumDurability, so if durability < minimumDurability then we can reasonably assume that the elytra will soon be broken without replacement
+ return true;
+ }
+
+ NonNullList inv = ctx.player().getInventory().items;
+ int qty = 0;
+ for (int i = 0; i < 36; i++) {
+ if (ElytraBehavior.isFireworks(inv.get(i))) {
+ qty += inv.get(i).getCount();
+ }
+ }
+ if (qty <= Baritone.settings().elytraMinFireworksBeforeLanding.value) {
+ return true;
+ }
+ return false;
+ }
+
+ @Override
+ public boolean isLoaded() {
+ return true;
+ }
+
+ @Override
+ public boolean isSafeToCancel() {
+ return !this.isActive() || !(this.state == State.FLYING || this.state == State.START_FLYING);
+ }
+
+ public enum State {
+ LOCATE_JUMP("Finding spot to jump off"),
+ PAUSE("Waiting for elytra path"),
+ GET_TO_JUMP("Walking to takeoff"),
+ START_FLYING("Begin flying"),
+ FLYING("Flying"),
+ LANDING("Landing");
+
+ public final String description;
+
+ State(String desc) {
+ this.description = desc;
+ }
+ }
+
+ @Override
+ public void onRenderPass(RenderEvent event) {
+ System.out.println(event.getPartialTicks() + " " + ctx.player().getXRot() + " " + ctx.player().getYRot() + " " + ctx.player().xRotO + " " + ctx.player().yRotO);
+
+ if (this.behavior != null) this.behavior.onRenderPass(event);
+ }
+
+ @Override
+ public void onWorldEvent(WorldEvent event) {
+ if (event.getWorld() != null && event.getState() == EventState.POST) {
+ // Exiting the world, just destroy
+ destroyBehaviorAsync();
+ }
+ }
+
+ @Override
+ public void onChunkEvent(ChunkEvent event) {
+ if (this.behavior != null) this.behavior.onChunkEvent(event);
+ }
+
+ @Override
+ public void onBlockChange(BlockChangeEvent event) {
+ if (this.behavior != null) this.behavior.onBlockChange(event);
+ }
+
+ @Override
+ public void onReceivePacket(PacketEvent event) {
+ if (this.behavior != null) this.behavior.onReceivePacket(event);
+ }
+
+ @Override
+ public void onPostTick(TickEvent event) {
+ IBaritoneProcess procThisTick = baritone.getPathingControlManager().mostRecentInControl().orElse(null);
+ if (this.behavior != null && procThisTick == this) this.behavior.onPostTick(event);
+ }
+
+ /**
+ * Custom calculation context which makes the player fall into lava
+ */
+ public static final class WalkOffCalculationContext extends CalculationContext {
+
+ public WalkOffCalculationContext(IBaritone baritone) {
+ super(baritone, true);
+ this.allowFallIntoLava = true;
+ this.minFallHeight = 8;
+ this.maxFallHeightNoWater = 10000;
+ }
+
+ @Override
+ public double costOfPlacingAt(int x, int y, int z, BlockState current) {
+ return COST_INF;
+ }
+
+ @Override
+ public double breakCostMultiplierAt(int x, int y, int z, BlockState current) {
+ return COST_INF;
+ }
+
+ @Override
+ public double placeBucketCost() {
+ return COST_INF;
+ }
+ }
+
+ private static boolean isInBounds(BlockPos pos) {
+ return pos.getY() >= 0 && pos.getY() < 128;
+ }
+
+ private boolean isSafeBlock(Block block) {
+ return block == Blocks.NETHERRACK || block == Blocks.GRAVEL || (block == Blocks.NETHER_BRICKS && Baritone.settings().elytraAllowLandOnNetherFortress.value);
+ }
+
+ private boolean isSafeBlock(BlockPos pos) {
+ return isSafeBlock(ctx.world().getBlockState(pos).getBlock());
+ }
+
+ private boolean isAtEdge(BlockPos pos) {
+ return !isSafeBlock(pos.north())
+ || !isSafeBlock(pos.south())
+ || !isSafeBlock(pos.east())
+ || !isSafeBlock(pos.west())
+ // corners
+ || !isSafeBlock(pos.north().west())
+ || !isSafeBlock(pos.north().east())
+ || !isSafeBlock(pos.south().west())
+ || !isSafeBlock(pos.south().east());
+ }
+
+ private boolean isColumnAir(BlockPos landingSpot, int minHeight) {
+ BlockPos.MutableBlockPos mut = new BlockPos.MutableBlockPos(landingSpot.getX(), landingSpot.getY(), landingSpot.getZ());
+ final int maxY = mut.getY() + minHeight;
+ for (int y = mut.getY() + 1; y <= maxY; y++) {
+ mut.set(mut.getX(), y, mut.getZ());
+ if (!(ctx.world().getBlockState(mut).getBlock() instanceof AirBlock)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ private boolean hasAirBubble(BlockPos pos) {
+ final int radius = 4; // Half of the full width, rounded down, as we're counting blocks in each direction from the center
+ BlockPos.MutableBlockPos mut = new BlockPos.MutableBlockPos();
+ for (int x = -radius; x <= radius; x++) {
+ for (int y = -radius; y <= radius; y++) {
+ for (int z = -radius; z <= radius; z++) {
+ mut.set(pos.getX() + x, pos.getY() + y, pos.getZ() + z);
+ if (!(ctx.world().getBlockState(mut).getBlock() instanceof AirBlock)) {
+ return false;
+ }
+ }
+ }
+ }
+
+ return true;
+ }
+
+ private BetterBlockPos checkLandingSpot(BlockPos pos, LongOpenHashSet checkedSpots) {
+ BlockPos.MutableBlockPos mut = new BlockPos.MutableBlockPos(pos.getX(), pos.getY(), pos.getZ());
+ while (mut.getY() >= 0) {
+ if (checkedSpots.contains(mut.asLong())) {
+ return null;
+ }
+ checkedSpots.add(mut.asLong());
+ Block block = ctx.world().getBlockState(mut).getBlock();
+
+ if (isSafeBlock(block)) {
+ if (!isAtEdge(mut)) {
+ return new BetterBlockPos(mut);
+ }
+ return null;
+ } else if (block != Blocks.AIR) {
+ return null;
+ }
+ mut.set(mut.getX(), mut.getY() - 1, mut.getZ());
+ }
+ return null; // void
+ }
+
+ private static final int LANDING_COLUMN_HEIGHT = 15;
+ private Set badLandingSpots = new HashSet<>();
+
+ private BetterBlockPos findSafeLandingSpot(BetterBlockPos start) {
+ Queue queue = new PriorityQueue<>(Comparator.comparingInt(pos -> (pos.x - start.x) * (pos.x - start.x) + (pos.z - start.z) * (pos.z - start.z)).thenComparingInt(pos -> -pos.y));
+ Set visited = new HashSet<>();
+ LongOpenHashSet checkedPositions = new LongOpenHashSet();
+ queue.add(start);
+
+ while (!queue.isEmpty()) {
+ BetterBlockPos pos = queue.poll();
+ if (ctx.world().isLoaded(pos) && isInBounds(pos) && ctx.world().getBlockState(pos).getBlock() == Blocks.AIR) {
+ BetterBlockPos actualLandingSpot = checkLandingSpot(pos, checkedPositions);
+ if (actualLandingSpot != null && isColumnAir(actualLandingSpot, LANDING_COLUMN_HEIGHT) && hasAirBubble(actualLandingSpot.above(LANDING_COLUMN_HEIGHT)) && !badLandingSpots.contains(actualLandingSpot.above(LANDING_COLUMN_HEIGHT))) {
+ return actualLandingSpot.above(LANDING_COLUMN_HEIGHT);
+ }
+ if (visited.add(pos.north())) queue.add(pos.north());
+ if (visited.add(pos.east())) queue.add(pos.east());
+ if (visited.add(pos.south())) queue.add(pos.south());
+ if (visited.add(pos.west())) queue.add(pos.west());
+ if (visited.add(pos.above())) queue.add(pos.above());
+ if (visited.add(pos.below())) queue.add(pos.below());
+ }
+ }
+ return null;
+ }
+}
diff --git a/src/main/java/baritone/process/FarmProcess.java b/src/main/java/baritone/process/FarmProcess.java
index b9308591c..c453beff2 100644
--- a/src/main/java/baritone/process/FarmProcess.java
+++ b/src/main/java/baritone/process/FarmProcess.java
@@ -18,8 +18,10 @@
package baritone.process;
import baritone.Baritone;
+import baritone.api.BaritoneAPI;
import baritone.api.pathing.goals.Goal;
import baritone.api.pathing.goals.GoalBlock;
+import baritone.api.pathing.goals.GoalGetToBlock;
import baritone.api.pathing.goals.GoalComposite;
import baritone.api.process.IFarmProcess;
import baritone.api.process.PathingCommand;
@@ -29,7 +31,6 @@ import baritone.api.utils.RayTraceUtils;
import baritone.api.utils.Rotation;
import baritone.api.utils.RotationUtils;
import baritone.api.utils.input.Input;
-import baritone.cache.WorldScanner;
import baritone.pathing.movement.MovementHelper;
import baritone.utils.BaritoneProcessHelper;
import net.minecraft.core.BlockPos;
@@ -45,6 +46,7 @@ import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.Blocks;
import net.minecraft.world.level.block.BonemealableBlock;
import net.minecraft.world.level.block.CactusBlock;
+import net.minecraft.world.level.block.CocoaBlock;
import net.minecraft.world.level.block.CropBlock;
import net.minecraft.world.level.block.NetherWartBlock;
import net.minecraft.world.level.block.SugarCaneBlock;
@@ -52,6 +54,7 @@ import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.phys.BlockHitResult;
import net.minecraft.world.phys.HitResult;
import net.minecraft.world.phys.Vec3;
+
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
@@ -90,6 +93,7 @@ public final class FarmProcess extends BaritoneProcessHelper implements IFarmPro
Items.POTATO,
Items.CARROT,
Items.NETHER_WART,
+ Items.COCOA_BEANS,
Blocks.SUGAR_CANE.asItem(),
Blocks.CACTUS.asItem()
);
@@ -123,6 +127,7 @@ public final class FarmProcess extends BaritoneProcessHelper implements IFarmPro
PUMPKIN(Blocks.PUMPKIN, state -> true),
MELON(Blocks.MELON, state -> true),
NETHERWART(Blocks.NETHER_WART, state -> state.getValue(NetherWartBlock.AGE) >= 3),
+ COCOA(Blocks.COCOA, state -> state.getValue(CocoaBlock.AGE) >= 2),
SUGARCANE(Blocks.SUGAR_CANE, null) {
@Override
public boolean readyToHarvest(Level world, BlockPos pos, BlockState state) {
@@ -180,6 +185,10 @@ public final class FarmProcess extends BaritoneProcessHelper implements IFarmPro
return !stack.isEmpty() && stack.getItem().equals(Items.NETHER_WART);
}
+ private boolean isCocoa(ItemStack stack) {
+ return !stack.isEmpty() && stack.getItem().equals(Items.COCOA_BEANS);
+ }
+
@Override
public PathingCommand onTick(boolean calcFailed, boolean isSafeToCancel) {
ArrayList scan = new ArrayList<>();
@@ -188,13 +197,14 @@ public final class FarmProcess extends BaritoneProcessHelper implements IFarmPro
}
if (Baritone.settings().replantCrops.value) {
scan.add(Blocks.FARMLAND);
+ scan.add(Blocks.JUNGLE_LOG);
if (Baritone.settings().replantNetherWart.value) {
scan.add(Blocks.SOUL_SAND);
}
}
if (Baritone.settings().mineGoalUpdateInterval.value != 0 && tickCount++ % Baritone.settings().mineGoalUpdateInterval.value == 0) {
- Baritone.getExecutor().execute(() -> locations = WorldScanner.INSTANCE.scanChunkRadius(ctx, scan, 256, 10, 10));
+ Baritone.getExecutor().execute(() -> locations = BaritoneAPI.getProvider().getWorldScanner().scanChunkRadius(ctx, scan, 256, 10, 10));
}
if (locations == null) {
return new PathingCommand(null, PathingCommandType.REQUEST_PAUSE);
@@ -203,6 +213,7 @@ public final class FarmProcess extends BaritoneProcessHelper implements IFarmPro
List openFarmland = new ArrayList<>();
List bonemealable = new ArrayList<>();
List openSoulsand = new ArrayList<>();
+ List openLog = new ArrayList<>();
for (BlockPos pos : locations) {
//check if the target block is out of range.
if (range != 0 && pos.distSqr(center) > range * range) {
@@ -223,6 +234,15 @@ public final class FarmProcess extends BaritoneProcessHelper implements IFarmPro
}
continue;
}
+ if (state.getBlock() == Blocks.JUNGLE_LOG) {
+ for (Direction direction : Direction.Plane.HORIZONTAL) {
+ if (ctx.world().getBlockState(pos.relative(direction)).getBlock() instanceof AirBlock) {
+ openLog.add(pos);
+ break;
+ }
+ }
+ continue;
+ }
if (readyForHarvest(ctx.world(), pos, state)) {
toBreak.add(pos);
continue;
@@ -251,7 +271,7 @@ public final class FarmProcess extends BaritoneProcessHelper implements IFarmPro
both.addAll(openSoulsand);
for (BlockPos pos : both) {
boolean soulsand = openSoulsand.contains(pos);
- Optional rot = RotationUtils.reachableOffset(ctx.player(), pos, new Vec3(pos.getX() + 0.5, pos.getY() + 1, pos.getZ() + 0.5), ctx.playerController().getBlockReachDistance(), false);
+ Optional rot = RotationUtils.reachableOffset(ctx, pos, new Vec3(pos.getX() + 0.5, pos.getY() + 1, pos.getZ() + 0.5), ctx.playerController().getBlockReachDistance(), false);
if (rot.isPresent() && isSafeToCancel && baritone.getInventoryBehavior().throwaway(true, soulsand ? this::isNetherWart : this::isPlantable)) {
HitResult result = RayTraceUtils.rayTraceTowards(ctx.player(), rot.get(), ctx.playerController().getBlockReachDistance());
if (result instanceof BlockHitResult && ((BlockHitResult) result).getDirection() == Direction.UP) {
@@ -263,6 +283,25 @@ public final class FarmProcess extends BaritoneProcessHelper implements IFarmPro
}
}
}
+ for (BlockPos pos : openLog) {
+ for (Direction dir : Direction.Plane.HORIZONTAL) {
+ if (!(ctx.world().getBlockState(pos.relative(dir)).getBlock() instanceof AirBlock)) {
+ continue;
+ }
+ Vec3 faceCenter = Vec3.atCenterOf(pos).add(Vec3.atLowerCornerOf(dir.getNormal()).scale(0.5));
+ Optional rot = RotationUtils.reachableOffset(ctx, pos, faceCenter, ctx.playerController().getBlockReachDistance(), false);
+ if (rot.isPresent() && isSafeToCancel && baritone.getInventoryBehavior().throwaway(true, this::isCocoa)) {
+ HitResult result = RayTraceUtils.rayTraceTowards(ctx.player(), rot.get(), ctx.playerController().getBlockReachDistance());
+ if (result instanceof BlockHitResult && ((BlockHitResult) result).getDirection() == dir) {
+ baritone.getLookBehavior().updateTarget(rot.get(), true);
+ if (ctx.isLookingAt(pos)) {
+ baritone.getInputOverrideHandler().setInputForceState(Input.CLICK_RIGHT, true);
+ }
+ return new PathingCommand(null, PathingCommandType.REQUEST_PAUSE);
+ }
+ }
+ }
+ }
for (BlockPos pos : bonemealable) {
Optional rot = RotationUtils.reachable(ctx, pos);
if (rot.isPresent() && isSafeToCancel && baritone.getInventoryBehavior().throwaway(true, this::isBoneMeal)) {
@@ -297,6 +336,15 @@ public final class FarmProcess extends BaritoneProcessHelper implements IFarmPro
goalz.add(new GoalBlock(pos.above()));
}
}
+ if (baritone.getInventoryBehavior().throwaway(false, this::isCocoa)) {
+ for (BlockPos pos : openLog) {
+ for (Direction direction : Direction.Plane.HORIZONTAL) {
+ if (ctx.world().getBlockState(pos.relative(direction)).getBlock() instanceof AirBlock) {
+ goalz.add(new GoalGetToBlock(pos.relative(direction)));
+ }
+ }
+ }
+ }
if (baritone.getInventoryBehavior().throwaway(false, this::isBoneMeal)) {
for (BlockPos pos : bonemealable) {
goalz.add(new GoalBlock(pos));
diff --git a/src/main/java/baritone/process/GetToBlockProcess.java b/src/main/java/baritone/process/GetToBlockProcess.java
index 88cc5bfa2..1352232d4 100644
--- a/src/main/java/baritone/process/GetToBlockProcess.java
+++ b/src/main/java/baritone/process/GetToBlockProcess.java
@@ -211,7 +211,7 @@ public final class GetToBlockProcess extends BaritoneProcessHelper implements IG
private boolean rightClick() {
for (BlockPos pos : knownLocations) {
- Optional reachable = RotationUtils.reachable(ctx.player(), pos, ctx.playerController().getBlockReachDistance());
+ Optional reachable = RotationUtils.reachable(ctx, pos, ctx.playerController().getBlockReachDistance());
if (reachable.isPresent()) {
baritone.getLookBehavior().updateTarget(reachable.get(), true);
if (knownLocations.contains(ctx.getSelectedBlock().orElse(null))) {
diff --git a/src/main/java/baritone/process/InventoryPauserProcess.java b/src/main/java/baritone/process/InventoryPauserProcess.java
new file mode 100644
index 000000000..fc9f4735a
--- /dev/null
+++ b/src/main/java/baritone/process/InventoryPauserProcess.java
@@ -0,0 +1,90 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.process;
+
+import baritone.Baritone;
+import baritone.api.process.PathingCommand;
+import baritone.api.process.PathingCommandType;
+import baritone.utils.BaritoneProcessHelper;
+
+public class InventoryPauserProcess extends BaritoneProcessHelper {
+
+ boolean pauseRequestedLastTick;
+ boolean safeToCancelLastTick;
+ int ticksOfStationary;
+
+ public InventoryPauserProcess(Baritone baritone) {
+ super(baritone);
+ }
+
+ @Override
+ public boolean isActive() {
+ if (ctx.player() == null || ctx.world() == null) {
+ return false;
+ }
+ return true;
+ }
+
+ private double motion() {
+ return ctx.player().getDeltaMovement().multiply(1, 0, 1).length();
+ }
+
+ private boolean stationaryNow() {
+ return motion() < 0.00001;
+ }
+
+ public boolean stationaryForInventoryMove() {
+ pauseRequestedLastTick = true;
+ return safeToCancelLastTick && ticksOfStationary > 1;
+ }
+
+ @Override
+ public PathingCommand onTick(boolean calcFailed, boolean isSafeToCancel) {
+ //logDebug(pauseRequestedLastTick + " " + safeToCancelLastTick + " " + ticksOfStationary);
+ safeToCancelLastTick = isSafeToCancel;
+ if (pauseRequestedLastTick) {
+ pauseRequestedLastTick = false;
+ if (stationaryNow()) {
+ ticksOfStationary++;
+ }
+ return new PathingCommand(null, PathingCommandType.REQUEST_PAUSE);
+ }
+ ticksOfStationary = 0;
+ return new PathingCommand(null, PathingCommandType.DEFER);
+ }
+
+ @Override
+ public void onLostControl() {
+
+ }
+
+ @Override
+ public String displayName0() {
+ return "inventory pauser";
+ }
+
+ @Override
+ public double priority() {
+ return 5.1; // slightly higher than backfill
+ }
+
+ @Override
+ public boolean isTemporary() {
+ return true;
+ }
+}
diff --git a/src/main/java/baritone/process/MineProcess.java b/src/main/java/baritone/process/MineProcess.java
index 3e5423b70..852e6ba3d 100644
--- a/src/main/java/baritone/process/MineProcess.java
+++ b/src/main/java/baritone/process/MineProcess.java
@@ -18,6 +18,7 @@
package baritone.process;
import baritone.Baritone;
+import baritone.api.BaritoneAPI;
import baritone.api.pathing.goals.*;
import baritone.api.process.IMineProcess;
import baritone.api.process.PathingCommand;
@@ -25,7 +26,6 @@ import baritone.api.process.PathingCommandType;
import baritone.api.utils.*;
import baritone.api.utils.input.Input;
import baritone.cache.CachedChunk;
-import baritone.cache.WorldScanner;
import baritone.pathing.movement.CalculationContext;
import baritone.pathing.movement.MovementHelper;
import baritone.utils.BaritoneProcessHelper;
@@ -320,6 +320,26 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
int zDiff = z - this.z;
return GoalBlock.calculate(xDiff, yDiff < -1 ? yDiff + 2 : yDiff == -1 ? 0 : yDiff, zDiff);
}
+
+ @Override
+ public boolean equals(Object o) {
+ return super.equals(o);
+ }
+
+ @Override
+ public int hashCode() {
+ return super.hashCode() * 393857768;
+ }
+
+ @Override
+ public String toString() {
+ return String.format(
+ "GoalThreeBlocks{x=%s,y=%s,z=%s}",
+ SettingsUtil.maybeCensor(x),
+ SettingsUtil.maybeCensor(y),
+ SettingsUtil.maybeCensor(z)
+ );
+ }
}
public List droppedItemsScan() {
@@ -363,7 +383,7 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
locs = prune(ctx, locs, filter, max, blacklist, dropped);
if (!untracked.isEmpty() || (Baritone.settings().extendCacheOnThreshold.value && locs.size() < max)) {
- locs.addAll(WorldScanner.INSTANCE.scanChunkRadius(
+ locs.addAll(BaritoneAPI.getProvider().getWorldScanner().scanChunkRadius(
ctx.getBaritone().getPlayerContext(),
filter,
max,
@@ -398,7 +418,7 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
// is an x-ray and it'll get caught
if (filter.has(bsi.get0(x, y, z))) {
BlockPos pos = new BlockPos(x, y, z);
- if ((Baritone.settings().legitMineIncludeDiagonals.value && knownOreLocations.stream().anyMatch(ore -> ore.distSqr(pos) <= 2 /* sq means this is pytha dist <= sqrt(2) */)) || RotationUtils.reachable(ctx.player(), pos, fakedBlockReachDistance).isPresent()) {
+ if ((Baritone.settings().legitMineIncludeDiagonals.value && knownOreLocations.stream().anyMatch(ore -> ore.distSqr(pos) <= 2 /* sq means this is pytha dist <= sqrt(2) */)) || RotationUtils.reachable(ctx, pos, fakedBlockReachDistance).isPresent()) {
knownOreLocations.add(pos);
}
}
@@ -438,6 +458,8 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
.filter(pos -> pos.getY() >= Baritone.settings().minYLevelWhileMining.value + ctx.world.dimensionType().minY())
+ .filter(pos -> pos.getY() <= Baritone.settings().maxYLevelWhileMining.value)
+
.filter(pos -> !blacklist.contains(pos))
.sorted(Comparator.comparingDouble(ctx.getBaritone().getPlayerContext().player().blockPosition()::distSqr))
diff --git a/src/main/java/baritone/process/elytra/BlockStateOctreeInterface.java b/src/main/java/baritone/process/elytra/BlockStateOctreeInterface.java
new file mode 100644
index 000000000..7db0e2d64
--- /dev/null
+++ b/src/main/java/baritone/process/elytra/BlockStateOctreeInterface.java
@@ -0,0 +1,54 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.process.elytra;
+
+import dev.babbaj.pathfinder.NetherPathfinder;
+import dev.babbaj.pathfinder.Octree;
+
+/**
+ * @author Brady
+ */
+public final class BlockStateOctreeInterface {
+
+ private final NetherPathfinderContext context;
+ private final long contextPtr;
+ transient long chunkPtr;
+
+ // Guarantee that the first lookup will fetch the context by setting MAX_VALUE
+ private int prevChunkX = Integer.MAX_VALUE;
+ private int prevChunkZ = Integer.MAX_VALUE;
+
+ public BlockStateOctreeInterface(final NetherPathfinderContext context) {
+ this.context = context;
+ this.contextPtr = context.context;
+ }
+
+ public boolean get0(final int x, final int y, final int z) {
+ if ((y | (127 - y)) < 0) {
+ return false;
+ }
+ final int chunkX = x >> 4;
+ final int chunkZ = z >> 4;
+ if (this.chunkPtr == 0 | ((chunkX ^ this.prevChunkX) | (chunkZ ^ this.prevChunkZ)) != 0) {
+ this.prevChunkX = chunkX;
+ this.prevChunkZ = chunkZ;
+ this.chunkPtr = NetherPathfinder.getOrCreateChunk(this.contextPtr, chunkX, chunkZ);
+ }
+ return Octree.getBlock(this.chunkPtr, x & 0xF, y & 0x7F, z & 0xF);
+ }
+}
diff --git a/src/main/java/baritone/process/elytra/ElytraBehavior.java b/src/main/java/baritone/process/elytra/ElytraBehavior.java
new file mode 100644
index 000000000..2b105b75e
--- /dev/null
+++ b/src/main/java/baritone/process/elytra/ElytraBehavior.java
@@ -0,0 +1,1308 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.process.elytra;
+
+import baritone.Baritone;
+import baritone.api.Settings;
+import baritone.api.behavior.look.IAimProcessor;
+import baritone.api.behavior.look.ITickableAimProcessor;
+import baritone.api.event.events.*;
+import baritone.api.pathing.goals.GoalBlock;
+import baritone.api.utils.*;
+import baritone.pathing.movement.MovementHelper;
+import baritone.process.ElytraProcess;
+import baritone.utils.BlockStateInterface;
+import baritone.utils.IRenderer;
+import baritone.utils.PathRenderer;
+import baritone.utils.accessor.IFireworkRocketEntity;
+import it.unimi.dsi.fastutil.floats.FloatArrayList;
+import it.unimi.dsi.fastutil.floats.FloatIterator;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.NonNullList;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.protocol.game.ClientboundPlayerPositionPacket;
+import net.minecraft.util.Mth;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.entity.EquipmentSlot;
+import net.minecraft.world.entity.projectile.FireworkRocketEntity;
+import net.minecraft.world.inventory.ClickType;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.level.ClipContext;
+import net.minecraft.world.level.block.AirBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.chunk.ChunkSource;
+import net.minecraft.world.level.chunk.LevelChunk;
+import net.minecraft.world.phys.AABB;
+import net.minecraft.world.phys.HitResult;
+import net.minecraft.world.phys.Vec3;
+
+import java.awt.*;
+import java.util.List;
+import java.util.Queue;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.function.UnaryOperator;
+
+import static baritone.utils.BaritoneMath.fastCeil;
+import static baritone.utils.BaritoneMath.fastFloor;
+
+public final class ElytraBehavior implements Helper {
+ private final Baritone baritone;
+ private final IPlayerContext ctx;
+
+ // Render stuff
+ private final List> clearLines;
+ private final List> blockedLines;
+ private List simulationLine;
+ private BlockPos aimPos;
+ private List visiblePath;
+
+ // :sunglasses:
+ public final NetherPathfinderContext context;
+ public final PathManager pathManager;
+ private final ElytraProcess process;
+
+ /**
+ * Remaining cool-down ticks between firework usage
+ */
+ private int remainingFireworkTicks;
+
+ /**
+ * Remaining cool-down ticks after the player's position and rotation are reset by the server
+ */
+ private int remainingSetBackTicks;
+
+ public boolean landingMode;
+
+ /**
+ * The most recent minimum number of firework boost ticks, equivalent to {@code 10 * (1 + Flight)}
+ *
+ * Updated every time a firework is automatically used
+ */
+ private int minimumBoostTicks;
+
+ private boolean deployedFireworkLastTick;
+ private final int[] nextTickBoostCounter;
+
+ private BlockStateInterface bsi;
+ private final BlockStateOctreeInterface boi;
+ public final BlockPos destination;
+ private final boolean appendDestination;
+
+ private final ExecutorService solverExecutor;
+ private Future solver;
+ private Solution pendingSolution;
+ private boolean solveNextTick;
+
+ private long timeLastCacheCull = 0L;
+
+ // auto swap
+ private int invTickCountdown = 0;
+ private final Queue invTransactionQueue = new LinkedList<>();
+
+ public ElytraBehavior(Baritone baritone, ElytraProcess process, BlockPos destination, boolean appendDestination) {
+ this.baritone = baritone;
+ this.ctx = baritone.getPlayerContext();
+ this.clearLines = new CopyOnWriteArrayList<>();
+ this.blockedLines = new CopyOnWriteArrayList<>();
+ this.pathManager = this.new PathManager();
+ this.process = process;
+ this.destination = destination;
+ this.appendDestination = appendDestination;
+ this.solverExecutor = Executors.newSingleThreadExecutor();
+ this.nextTickBoostCounter = new int[2];
+
+ this.context = new NetherPathfinderContext(Baritone.settings().elytraNetherSeed.value);
+ this.boi = new BlockStateOctreeInterface(context);
+ }
+
+ public final class PathManager {
+
+ public NetherPath path;
+ private boolean completePath;
+ private boolean recalculating;
+
+ private int maxPlayerNear;
+ private int ticksNearUnchanged;
+ private int playerNear;
+
+ public PathManager() {
+ // lol imagine initializing fields normally
+ this.clear();
+ }
+
+ public void tick() {
+ // Recalculate closest path node
+ this.updatePlayerNear();
+ final int prevMaxNear = this.maxPlayerNear;
+ this.maxPlayerNear = Math.max(this.maxPlayerNear, this.playerNear);
+
+ if (this.maxPlayerNear == prevMaxNear && ctx.player().isFallFlying()) {
+ this.ticksNearUnchanged++;
+ } else {
+ this.ticksNearUnchanged = 0;
+ }
+
+ // Obstacles are more important than an incomplete path, handle those first.
+ this.pathfindAroundObstacles();
+ this.attemptNextSegment();
+ }
+
+ public CompletableFuture pathToDestination() {
+ return this.pathToDestination(ctx.playerFeet());
+ }
+
+ public CompletableFuture pathToDestination(final BlockPos from) {
+ final long start = System.nanoTime();
+ return this.path0(from, ElytraBehavior.this.destination, UnaryOperator.identity())
+ .thenRun(() -> {
+ final double distance = this.path.get(0).distanceTo(this.path.get(this.path.size() - 1));
+ if (this.completePath) {
+ logDirect(String.format("Computed path (%.1f blocks in %.4f seconds)", distance, (System.nanoTime() - start) / 1e9d));
+ } else {
+ logDirect(String.format("Computed segment (Next %.1f blocks in %.4f seconds)", distance, (System.nanoTime() - start) / 1e9d));
+ }
+ })
+ .whenComplete((result, ex) -> {
+ this.recalculating = false;
+ if (ex != null) {
+ final Throwable cause = ex.getCause();
+ if (cause instanceof PathCalculationException) {
+ logDirect("Failed to compute path to destination");
+ } else {
+ logUnhandledException(cause);
+ }
+ }
+ });
+ }
+
+ public CompletableFuture pathRecalcSegment(final int upToIncl) {
+ if (this.recalculating) {
+ throw new IllegalStateException("already recalculating");
+ }
+
+ this.recalculating = true;
+ final List after = this.path.subList(upToIncl + 1, this.path.size());
+ final boolean complete = this.completePath;
+
+ return this.path0(ctx.playerFeet(), this.path.get(upToIncl), segment -> segment.append(after.stream(), complete))
+ .whenComplete((result, ex) -> {
+ this.recalculating = false;
+ if (ex != null) {
+ final Throwable cause = ex.getCause();
+ if (cause instanceof PathCalculationException) {
+ logDirect("Failed to recompute segment");
+ } else {
+ logUnhandledException(cause);
+ }
+ }
+ });
+ }
+
+ public void pathNextSegment(final int afterIncl) {
+ if (this.recalculating) {
+ return;
+ }
+
+ this.recalculating = true;
+ final List before = this.path.subList(0, afterIncl + 1);
+ final long start = System.nanoTime();
+ final BetterBlockPos pathStart = this.path.get(afterIncl);
+
+ this.path0(pathStart, ElytraBehavior.this.destination, segment -> segment.prepend(before.stream()))
+ .thenRun(() -> {
+ final int recompute = this.path.size() - before.size() - 1;
+ final double distance = this.path.get(0).distanceTo(this.path.get(recompute));
+
+ if (this.completePath) {
+ logDirect(String.format("Computed path (%.1f blocks in %.4f seconds)", distance, (System.nanoTime() - start) / 1e9d));
+ } else {
+ logDirect(String.format("Computed segment (Next %.1f blocks in %.4f seconds)", distance, (System.nanoTime() - start) / 1e9d));
+ }
+ })
+ .whenComplete((result, ex) -> {
+ this.recalculating = false;
+ if (ex != null) {
+ final Throwable cause = ex.getCause();
+ if (cause instanceof PathCalculationException) {
+ logDirect("Failed to compute next segment");
+ if (ctx.player().distanceToSqr(pathStart.getCenter()) < 16 * 16) {
+ logDirect("Player is near the segment start, therefore repeating this calculation is pointless. Marking as complete");
+ completePath = true;
+ }
+ } else {
+ logUnhandledException(cause);
+ }
+ }
+ });
+ }
+
+ public void clear() {
+ this.path = NetherPath.emptyPath();
+ this.completePath = true;
+ this.recalculating = false;
+ this.playerNear = 0;
+ this.ticksNearUnchanged = 0;
+ this.maxPlayerNear = 0;
+ }
+
+ private void setPath(final UnpackedSegment segment) {
+ List path = segment.collect();
+ if (ElytraBehavior.this.appendDestination) {
+ BlockPos dest = ElytraBehavior.this.destination;
+ BlockPos last = !path.isEmpty() ? path.get(path.size() - 1) : null;
+ if (last != null && ElytraBehavior.this.clearView(Vec3.atLowerCornerOf(dest), Vec3.atLowerCornerOf(last), false)) {
+ path.add(new BetterBlockPos(dest));
+ } else {
+ logDirect("unable to land at " + ElytraBehavior.this.destination);
+ process.landingSpotIsBad(new BetterBlockPos(ElytraBehavior.this.destination));
+ }
+ }
+ this.path = new NetherPath(path);
+ this.completePath = segment.isFinished();
+ this.playerNear = 0;
+ this.ticksNearUnchanged = 0;
+ this.maxPlayerNear = 0;
+ }
+
+ public NetherPath getPath() {
+ return this.path;
+ }
+
+ public int getNear() {
+ return this.playerNear;
+ }
+
+ // mickey resigned
+ private CompletableFuture path0(BlockPos src, BlockPos dst, UnaryOperator operator) {
+ return ElytraBehavior.this.context.pathFindAsync(src, dst)
+ .thenApply(UnpackedSegment::from)
+ .thenApply(operator)
+ .thenAcceptAsync(this::setPath, ctx.minecraft()::execute);
+ }
+
+ private void pathfindAroundObstacles() {
+ if (this.recalculating) {
+ return;
+ }
+
+ int rangeStartIncl = playerNear;
+ int rangeEndExcl = playerNear;
+ while (rangeEndExcl < path.size() && ctx.world().isLoaded(path.get(rangeEndExcl))) {
+ rangeEndExcl++;
+ }
+ // rangeEndExcl now represents an index either not in the path, or just outside render distance
+ if (rangeStartIncl >= rangeEndExcl) {
+ // not loaded yet?
+ return;
+ }
+ final BetterBlockPos rangeStart = path.get(rangeStartIncl);
+ if (!ElytraBehavior.this.passable(rangeStart.x, rangeStart.y, rangeStart.z, false)) {
+ // we're in a wall
+ return; // previous iterations of this function SHOULD have fixed this by now :rage_cat:
+ }
+
+ if (ElytraBehavior.this.process.state != ElytraProcess.State.LANDING && this.ticksNearUnchanged > 100) {
+ this.pathRecalcSegment(rangeEndExcl - 1)
+ .thenRun(() -> {
+ logDirect("Recalculating segment, no progress in last 100 ticks");
+ });
+ this.ticksNearUnchanged = 0;
+ return;
+ }
+
+ boolean canSeeAny = false;
+ for (int i = rangeStartIncl; i < rangeEndExcl - 1; i++) {
+ if (ElytraBehavior.this.clearView(ctx.playerFeetAsVec(), this.path.getVec(i), false) || ElytraBehavior.this.clearView(ctx.playerHead(), this.path.getVec(i), false)) {
+ canSeeAny = true;
+ }
+ if (!ElytraBehavior.this.clearView(this.path.getVec(i), this.path.getVec(i + 1), false)) {
+ // obstacle. where do we return to pathing?
+ // find the next valid segment
+ final BetterBlockPos blockage = this.path.get(i);
+ final double distance = ctx.playerFeet().distanceTo(this.path.get(rangeEndExcl - 1));
+
+ final long start = System.nanoTime();
+ this.pathRecalcSegment(rangeEndExcl - 1)
+ .thenRun(() -> {
+ logDirect(String.format("Recalculated segment around path blockage near %s %s %s (next %.1f blocks in %.4f seconds)",
+ SettingsUtil.maybeCensor(blockage.x),
+ SettingsUtil.maybeCensor(blockage.y),
+ SettingsUtil.maybeCensor(blockage.z),
+ distance,
+ (System.nanoTime() - start) / 1e9d
+ ));
+ });
+ return;
+ }
+ }
+ if (!canSeeAny && rangeStartIncl < rangeEndExcl - 2 && process.state != ElytraProcess.State.GET_TO_JUMP) {
+ this.pathRecalcSegment(rangeEndExcl - 1).thenRun(() -> logDirect("Recalculated segment since no path points were visible"));
+ }
+ }
+
+ private void attemptNextSegment() {
+ if (this.recalculating) {
+ return;
+ }
+
+ final int last = this.path.size() - 1;
+ if (!this.completePath && ctx.world().isLoaded(this.path.get(last))) {
+ this.pathNextSegment(last);
+ }
+ }
+
+ public void updatePlayerNear() {
+ if (this.path.isEmpty()) {
+ return;
+ }
+
+ int index = this.playerNear;
+ final BetterBlockPos pos = ctx.playerFeet();
+ for (int i = index; i >= Math.max(index - 1000, 0); i -= 10) {
+ if (path.get(i).distanceSq(pos) < path.get(index).distanceSq(pos)) {
+ index = i; // intentional: this changes the bound of the loop
+ }
+ }
+ for (int i = index; i < Math.min(index + 1000, path.size()); i += 10) {
+ if (path.get(i).distanceSq(pos) < path.get(index).distanceSq(pos)) {
+ index = i; // intentional: this changes the bound of the loop
+ }
+ }
+ for (int i = index; i >= Math.max(index - 50, 0); i--) {
+ if (path.get(i).distanceSq(pos) < path.get(index).distanceSq(pos)) {
+ index = i; // intentional: this changes the bound of the loop
+ }
+ }
+ for (int i = index; i < Math.min(index + 50, path.size()); i++) {
+ if (path.get(i).distanceSq(pos) < path.get(index).distanceSq(pos)) {
+ index = i; // intentional: this changes the bound of the loop
+ }
+ }
+ this.playerNear = index;
+ }
+
+ public boolean isComplete() {
+ return this.completePath;
+ }
+ }
+
+ public void onRenderPass(RenderEvent event) {
+
+ final Settings settings = Baritone.settings();
+ if (this.visiblePath != null) {
+ PathRenderer.drawPath(event.getModelViewStack(), this.visiblePath, 0, Color.RED, false, 0, 0, 0.0D);
+ }
+ if (this.aimPos != null) {
+ PathRenderer.drawGoal(event.getModelViewStack(), ctx, new GoalBlock(this.aimPos), event.getPartialTicks(), Color.GREEN);
+ }
+ if (!this.clearLines.isEmpty() && settings.elytraRenderRaytraces.value) {
+ IRenderer.startLines(Color.GREEN, settings.pathRenderLineWidthPixels.value, settings.renderPathIgnoreDepth.value);
+ for (Pair line : this.clearLines) {
+ IRenderer.emitLine(event.getModelViewStack(), line.first(), line.second());
+ }
+ IRenderer.endLines(settings.renderPathIgnoreDepth.value);
+ }
+ if (!this.blockedLines.isEmpty() && Baritone.settings().elytraRenderRaytraces.value) {
+ IRenderer.startLines(Color.BLUE, settings.pathRenderLineWidthPixels.value, settings.renderPathIgnoreDepth.value);
+ for (Pair line : this.blockedLines) {
+ IRenderer.emitLine(event.getModelViewStack(), line.first(), line.second());
+ }
+ IRenderer.endLines(settings.renderPathIgnoreDepth.value);
+ }
+ if (this.simulationLine != null && Baritone.settings().elytraRenderSimulation.value) {
+ IRenderer.startLines(new Color(0x36CCDC), settings.pathRenderLineWidthPixels.value, settings.renderPathIgnoreDepth.value);
+ final Vec3 offset = ctx.player().getPosition(event.getPartialTicks());
+ for (int i = 0; i < this.simulationLine.size() - 1; i++) {
+ final Vec3 src = this.simulationLine.get(i).add(offset);
+ final Vec3 dst = this.simulationLine.get(i + 1).add(offset);
+ IRenderer.emitLine(event.getModelViewStack(), src, dst);
+ }
+ IRenderer.endLines(settings.renderPathIgnoreDepth.value);
+ }
+ }
+
+ public void onChunkEvent(ChunkEvent event) {
+ if (event.isPostPopulate() && this.context != null) {
+ final LevelChunk chunk = ctx.world().getChunk(event.getX(), event.getZ());
+ this.context.queueForPacking(chunk);
+ }
+ }
+
+ public void onBlockChange(BlockChangeEvent event) {
+ this.context.queueBlockUpdate(event);
+ }
+
+ public void onReceivePacket(PacketEvent event) {
+ if (event.getPacket() instanceof ClientboundPlayerPositionPacket) {
+ ctx.minecraft().execute(() -> {
+ this.remainingSetBackTicks = Baritone.settings().elytraFireworkSetbackUseDelay.value;
+ });
+ }
+ }
+
+ public void pathTo() {
+ if (!Baritone.settings().elytraAutoJump.value || ctx.player().isFallFlying()) {
+ this.pathManager.pathToDestination();
+ }
+ }
+
+ public void destroy() {
+ if (this.solver != null) {
+ this.solver.cancel(true);
+ }
+ this.solverExecutor.shutdown();
+ try {
+ while (!this.solverExecutor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS)) {}
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ this.context.destroy();
+ }
+
+ public void repackChunks() {
+ ChunkSource chunkProvider = ctx.world().getChunkSource();
+
+ BetterBlockPos playerPos = ctx.playerFeet();
+
+ int playerChunkX = playerPos.getX() >> 4;
+ int playerChunkZ = playerPos.getZ() >> 4;
+
+ int minX = playerChunkX - 40;
+ int minZ = playerChunkZ - 40;
+ int maxX = playerChunkX + 40;
+ int maxZ = playerChunkZ + 40;
+
+ for (int x = minX; x <= maxX; x++) {
+ for (int z = minZ; z <= maxZ; z++) {
+ LevelChunk chunk = chunkProvider.getChunk(x, z, false);
+
+ if (chunk != null && !chunk.isEmpty()) {
+ this.context.queueForPacking(chunk);
+ }
+ }
+ }
+ }
+
+ public void onTick() {
+ synchronized (this.context.cullingLock) {
+ this.onTick0();
+ }
+ final long now = System.currentTimeMillis();
+ if ((now - this.timeLastCacheCull) / 1000 > Baritone.settings().elytraTimeBetweenCacheCullSecs.value) {
+ this.context.queueCacheCulling(ctx.player().chunkPosition().x, ctx.player().chunkPosition().z, Baritone.settings().elytraCacheCullDistance.value, this.boi);
+ this.timeLastCacheCull = now;
+ }
+ }
+
+ private void onTick0() {
+ // Fetch the previous solution, regardless of if it's going to be used
+ this.pendingSolution = null;
+ if (this.solver != null) {
+ try {
+ this.pendingSolution = this.solver.get();
+ } catch (Exception ignored) {
+ // it doesn't matter if get() fails since the solution can just be recalculated synchronously
+ } finally {
+ this.solver = null;
+ }
+ }
+
+ tickInventoryTransactions();
+
+ // Certified mojang employee incident
+ if (this.remainingFireworkTicks > 0) {
+ this.remainingFireworkTicks--;
+ }
+ if (this.remainingSetBackTicks > 0) {
+ this.remainingSetBackTicks--;
+ }
+ if (!this.getAttachedFirework().isPresent()) {
+ this.minimumBoostTicks = 0;
+ }
+
+ // Reset rendered elements
+ this.clearLines.clear();
+ this.blockedLines.clear();
+ this.visiblePath = null;
+ this.simulationLine = null;
+ this.aimPos = null;
+
+ final List path = this.pathManager.getPath();
+ if (path.isEmpty()) {
+ return;
+ } else if (this.destination == null) {
+ this.pathManager.clear();
+ return;
+ }
+
+ // ctx AND context???? :DDD
+ this.bsi = new BlockStateInterface(ctx);
+ this.pathManager.tick();
+
+ final int playerNear = this.pathManager.getNear();
+ this.visiblePath = path.subList(
+ Math.max(playerNear - 30, 0),
+ Math.min(playerNear + 100, path.size())
+ );
+ }
+
+ /**
+ * Called by {@link baritone.process.ElytraProcess#onTick(boolean, boolean)} when the process is in control and the player is flying
+ */
+ public void tick() {
+ if (this.pathManager.getPath().isEmpty()) {
+ return;
+ }
+
+ trySwapElytra();
+
+ if (ctx.player().horizontalCollision) {
+ logDirect("hbonk");
+ }
+ if (ctx.player().verticalCollision) {
+ logDirect("vbonk");
+ }
+
+ final SolverContext solverContext = this.new SolverContext(false);
+ this.solveNextTick = true;
+
+ // If there's no previously calculated solution to use, or the context used at the end of last tick doesn't match this tick
+ final Solution solution;
+ if (this.pendingSolution == null || !this.pendingSolution.context.equals(solverContext)) {
+ solution = this.solveAngles(solverContext);
+ } else {
+ solution = this.pendingSolution;
+ }
+
+ if (this.deployedFireworkLastTick) {
+ this.nextTickBoostCounter[solverContext.boost.isBoosted() ? 1 : 0]++;
+ this.deployedFireworkLastTick = false;
+ }
+
+ if (solution == null) {
+ logDirect("no solution");
+ return;
+ }
+
+ baritone.getLookBehavior().updateTarget(solution.rotation, false);
+
+ if (!solution.solvedPitch) {
+ logDirect("no pitch solution, probably gonna crash in a few ticks LOL!!!");
+ return;
+ } else {
+ this.aimPos = new BetterBlockPos(solution.goingTo.x, solution.goingTo.y, solution.goingTo.z);
+ }
+
+ this.tickUseFireworks(
+ solution.context.start,
+ solution.goingTo,
+ solution.context.boost.isBoosted(),
+ solution.forceUseFirework
+ );
+ }
+
+ public void onPostTick(TickEvent event) {
+ if (event.getType() == TickEvent.Type.IN && this.solveNextTick) {
+ // We're at the end of the tick, the player's position likely updated and the closest path node could've
+ // changed. Updating it now will avoid unnecessary recalculation on the main thread.
+ this.pathManager.updatePlayerNear();
+
+ final SolverContext context = this.new SolverContext(true);
+ this.solver = this.solverExecutor.submit(() -> this.solveAngles(context));
+ this.solveNextTick = false;
+ }
+ }
+
+ private Solution solveAngles(final SolverContext context) {
+ final NetherPath path = context.path;
+ final int playerNear = landingMode ? path.size() - 1 : context.playerNear;
+ final Vec3 start = context.start;
+ Solution solution = null;
+
+ for (int relaxation = 0; relaxation < 3; relaxation++) { // try for a strict solution first, then relax more and more (if we're in a corner or near some blocks, it will have to relax its constraints a bit)
+ int[] heights = context.boost.isBoosted() ? new int[]{20, 10, 5, 0} : new int[]{0}; // attempt to gain height, if we can, so as not to waste the boost
+ int lookahead = relaxation == 0 ? 2 : 3; // ideally this would be expressed as a distance in blocks, rather than a number of voxel steps
+ //int minStep = Math.max(0, playerNear - relaxation);
+ int minStep = playerNear;
+
+ for (int i = Math.min(playerNear + 20, path.size() - 1); i >= minStep; i--) {
+ final List> candidates = new ArrayList<>();
+ for (int dy : heights) {
+ if (relaxation == 0 || i == minStep) {
+ // no interp
+ candidates.add(new Pair<>(path.getVec(i), dy));
+ } else if (relaxation == 1) {
+ final double[] interps = new double[]{1.0, 0.75, 0.5, 0.25};
+ for (double interp : interps) {
+ final Vec3 dest = interp == 1.0
+ ? path.getVec(i)
+ : path.getVec(i).scale(interp).add(path.getVec(i - 1).scale(1.0 - interp));
+ candidates.add(new Pair<>(dest, dy));
+ }
+ } else {
+ // Create a point along the segment every block
+ final Vec3 delta = path.getVec(i).subtract(path.getVec(i - 1));
+ final int steps = fastFloor(delta.length());
+ final Vec3 step = delta.normalize();
+ Vec3 stepped = path.getVec(i);
+ for (int interp = 0; interp < steps; interp++) {
+ candidates.add(new Pair<>(stepped, dy));
+ stepped = stepped.subtract(step);
+ }
+ }
+ }
+
+ for (final Pair candidate : candidates) {
+ final Integer augment = candidate.second();
+ Vec3 dest = candidate.first().add(0, augment, 0);
+ if (landingMode) {
+ dest = dest.add(0.5, 0.5, 0.5);
+ }
+
+ if (augment != 0) {
+ if (i + lookahead >= path.size()) {
+ continue;
+ }
+ if (start.distanceTo(dest) < 40) {
+ if (!this.clearView(dest, path.getVec(i + lookahead).add(0, augment, 0), false)
+ || !this.clearView(dest, path.getVec(i + lookahead), false)) {
+ // aka: don't go upwards if doing so would prevent us from being able to see the next position **OR** the modified next position
+ continue;
+ }
+ } else {
+ // but if it's far away, allow gaining altitude if we could lose it again by the time we get there
+ if (!this.clearView(dest, path.getVec(i), false)) {
+ continue;
+ }
+ }
+ }
+
+ final double minAvoidance = Baritone.settings().elytraMinimumAvoidance.value;
+ final Double growth = relaxation == 2 ? null
+ : relaxation == 0 ? 2 * minAvoidance : minAvoidance;
+
+ if (this.isHitboxClear(context, dest, growth)) {
+ // Yaw is trivial, just calculate the rotation required to face the destination
+ final float yaw = RotationUtils.calcRotationFromVec3d(start, dest, ctx.playerRotations()).getYaw();
+
+ final Pair pitch = this.solvePitch(context, dest, relaxation);
+ if (pitch == null) {
+ solution = new Solution(context, new Rotation(yaw, ctx.playerRotations().getPitch()), null, false, false);
+ continue;
+ }
+
+ // A solution was found with yaw AND pitch, so just immediately return it.
+ return new Solution(context, new Rotation(yaw, pitch.first()), dest, true, pitch.second());
+ }
+ }
+ }
+ }
+ return solution;
+ }
+
+ private void tickUseFireworks(final Vec3 start, final Vec3 goingTo, final boolean isBoosted, final boolean forceUseFirework) {
+ if (this.remainingSetBackTicks > 0) {
+ logDebug("waiting for elytraFireworkSetbackUseDelay: " + this.remainingSetBackTicks);
+ return;
+ }
+ if (this.landingMode) {
+ return;
+ }
+ final boolean useOnDescend = !Baritone.settings().elytraConserveFireworks.value || ctx.player().position().y < goingTo.y + 5;
+ final double currentSpeed = new Vec3(
+ ctx.player().getDeltaMovement().x,
+ // ignore y component if we are BOTH below where we want to be AND descending
+ ctx.player().position().y < goingTo.y ? Math.max(0, ctx.player().getDeltaMovement().y) : ctx.player().getDeltaMovement().y,
+ ctx.player().getDeltaMovement().z
+ ).lengthSqr();
+
+ final double elytraFireworkSpeed = Baritone.settings().elytraFireworkSpeed.value;
+ if (this.remainingFireworkTicks <= 0 && (forceUseFirework || (!isBoosted
+ && useOnDescend
+ && (ctx.player().position().y < goingTo.y - 5 || start.distanceTo(new Vec3(goingTo.x + 0.5, ctx.player().position().y, goingTo.z + 0.5)) > 5) // UGH!!!!!!!
+ && currentSpeed < elytraFireworkSpeed * elytraFireworkSpeed))
+ ) {
+ // Prioritize boosting fireworks over regular ones
+ // TODO: Take the minimum boost time into account?
+ if (!baritone.getInventoryBehavior().throwaway(true, ElytraBehavior::isBoostingFireworks) &&
+ !baritone.getInventoryBehavior().throwaway(true, ElytraBehavior::isFireworks)) {
+ logDirect("no fireworks");
+ return;
+ }
+ logDirect("attempting to use firework" + (forceUseFirework ? " (forced)" : ""));
+ ctx.playerController().processRightClick(ctx.player(), ctx.world(), InteractionHand.MAIN_HAND);
+ this.minimumBoostTicks = 10 * (1 + getFireworkBoost(ctx.player().getItemInHand(InteractionHand.MAIN_HAND)).orElse(0));
+ this.remainingFireworkTicks = 10;
+ this.deployedFireworkLastTick = true;
+ }
+ }
+
+ private final class SolverContext {
+
+ public final NetherPath path;
+ public final int playerNear;
+ public final Vec3 start;
+ public final Vec3 motion;
+ public final AABB boundingBox;
+ public final boolean ignoreLava;
+ public final FireworkBoost boost;
+ public final IAimProcessor aimProcessor;
+
+ /**
+ * Creates a new SolverContext using the current state of the path, player, and firework boost at the time of
+ * construction.
+ *
+ * @param async Whether the computation is being done asynchronously at the end of a game tick.
+ */
+ public SolverContext(boolean async) {
+ this.path = ElytraBehavior.this.pathManager.getPath();
+ this.playerNear = ElytraBehavior.this.pathManager.getNear();
+
+ this.start = ctx.playerFeetAsVec();
+ this.motion = ctx.playerMotion();
+ this.boundingBox = ctx.player().getBoundingBox();
+ this.ignoreLava = ctx.player().isInLava();
+
+ final Integer fireworkTicksExisted;
+ if (async && ElytraBehavior.this.deployedFireworkLastTick) {
+ final int[] counter = ElytraBehavior.this.nextTickBoostCounter;
+ fireworkTicksExisted = counter[1] > counter[0] ? 0 : null;
+ } else {
+ fireworkTicksExisted = ElytraBehavior.this.getAttachedFirework().map(e -> e.tickCount).orElse(null);
+ }
+ this.boost = new FireworkBoost(fireworkTicksExisted, ElytraBehavior.this.minimumBoostTicks);
+
+ ITickableAimProcessor aim = ElytraBehavior.this.baritone.getLookBehavior().getAimProcessor().fork();
+ if (async) {
+ // async computation is done at the end of a tick, advance by 1 to prepare for the next tick
+ aim.advance(1);
+ }
+ this.aimProcessor = aim;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || o.getClass() != SolverContext.class) {
+ return false;
+ }
+
+ SolverContext other = (SolverContext) o;
+ return this.path == other.path // Contents aren't modified, just compare by reference
+ && this.playerNear == other.playerNear
+ && Objects.equals(this.start, other.start)
+ && Objects.equals(this.motion, other.motion)
+ && Objects.equals(this.boundingBox, other.boundingBox)
+ && this.ignoreLava == other.ignoreLava
+ && Objects.equals(this.boost, other.boost);
+ }
+ }
+
+ private static final class FireworkBoost {
+
+ private final Integer fireworkTicksExisted;
+ private final int minimumBoostTicks;
+ private final int maximumBoostTicks;
+
+ /**
+ * @param fireworkTicksExisted The ticksExisted of the attached firework entity, or {@code null} if no entity.
+ * @param minimumBoostTicks The minimum number of boost ticks that the attached firework entity, if any, will
+ * provide.
+ */
+ public FireworkBoost(final Integer fireworkTicksExisted, final int minimumBoostTicks) {
+ this.fireworkTicksExisted = fireworkTicksExisted;
+
+ // this.lifetime = 10 * i + this.rand.nextInt(6) + this.rand.nextInt(7);
+ this.minimumBoostTicks = minimumBoostTicks;
+ this.maximumBoostTicks = minimumBoostTicks + 11;
+ }
+
+ public boolean isBoosted() {
+ return this.fireworkTicksExisted != null;
+ }
+
+ /**
+ * @return The guaranteed number of remaining ticks with boost
+ */
+ public int getGuaranteedBoostTicks() {
+ return this.isBoosted() ? Math.max(0, this.minimumBoostTicks - this.fireworkTicksExisted) : 0;
+ }
+
+ /**
+ * @return The maximum number of remaining ticks with boost
+ */
+ public int getMaximumBoostTicks() {
+ return this.isBoosted() ? Math.max(0, this.maximumBoostTicks - this.fireworkTicksExisted) : 0;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || o.getClass() != FireworkBoost.class) {
+ return false;
+ }
+
+ FireworkBoost other = (FireworkBoost) o;
+ if (!this.isBoosted() && !other.isBoosted()) {
+ return true;
+ }
+
+ return Objects.equals(this.fireworkTicksExisted, other.fireworkTicksExisted)
+ && this.minimumBoostTicks == other.minimumBoostTicks
+ && this.maximumBoostTicks == other.maximumBoostTicks;
+ }
+ }
+
+ private static final class PitchResult {
+
+ public final float pitch;
+ public final double dot;
+ public final List steps;
+
+ public PitchResult(float pitch, double dot, List steps) {
+ this.pitch = pitch;
+ this.dot = dot;
+ this.steps = steps;
+ }
+ }
+
+ private static final class Solution {
+
+ public final SolverContext context;
+ public final Rotation rotation;
+ public final Vec3 goingTo;
+ public final boolean solvedPitch;
+ public final boolean forceUseFirework;
+
+ public Solution(SolverContext context, Rotation rotation, Vec3 goingTo, boolean solvedPitch, boolean forceUseFirework) {
+ this.context = context;
+ this.rotation = rotation;
+ this.goingTo = goingTo;
+ this.solvedPitch = solvedPitch;
+ this.forceUseFirework = forceUseFirework;
+ }
+ }
+
+ public static boolean isFireworks(final ItemStack itemStack) {
+ if (itemStack.getItem() != Items.FIREWORK_ROCKET) {
+ return false;
+ }
+ // If it has NBT data, make sure it won't cause us to explode.
+ final CompoundTag compound = itemStack.getTagElement("Fireworks");
+ return compound == null || !compound.getAllKeys().contains("Explosions");
+ }
+
+ private static boolean isBoostingFireworks(final ItemStack itemStack) {
+ return getFireworkBoost(itemStack).isPresent();
+ }
+
+ private static OptionalInt getFireworkBoost(final ItemStack itemStack) {
+ if (isFireworks(itemStack)) {
+ final CompoundTag compound = itemStack.getTagElement("Fireworks");
+ if (compound != null && compound.getAllKeys().contains("Flight")) {
+ return OptionalInt.of(compound.getByte("Flight"));
+ }
+ }
+ return OptionalInt.empty();
+ }
+
+ private Optional getAttachedFirework() {
+ return ctx.entitiesStream()
+ .filter(x -> x instanceof FireworkRocketEntity)
+ .filter(x -> Objects.equals(((IFireworkRocketEntity) x).getBoostedEntity(), ctx.player()))
+ .map(x -> (FireworkRocketEntity) x)
+ .findFirst();
+ }
+
+ private boolean isHitboxClear(final SolverContext context, final Vec3 dest, final Double growAmount) {
+ final Vec3 start = context.start;
+ final boolean ignoreLava = context.ignoreLava;
+
+ if (!this.clearView(start, dest, ignoreLava)) {
+ return false;
+ }
+ if (growAmount == null) {
+ return true;
+ }
+
+ final AABB bb = context.boundingBox.inflate(growAmount);
+
+ final double ox = dest.x - start.x;
+ final double oy = dest.y - start.y;
+ final double oz = dest.z - start.z;
+
+ final double[] src = new double[]{
+ bb.minX, bb.minY, bb.minZ,
+ bb.minX, bb.minY, bb.maxZ,
+ bb.minX, bb.maxY, bb.minZ,
+ bb.minX, bb.maxY, bb.maxZ,
+ bb.maxX, bb.minY, bb.minZ,
+ bb.maxX, bb.minY, bb.maxZ,
+ bb.maxX, bb.maxY, bb.minZ,
+ bb.maxX, bb.maxY, bb.maxZ,
+ };
+ final double[] dst = new double[]{
+ bb.minX + ox, bb.minY + oy, bb.minZ + oz,
+ bb.minX + ox, bb.minY + oy, bb.maxZ + oz,
+ bb.minX + ox, bb.maxY + oy, bb.minZ + oz,
+ bb.minX + ox, bb.maxY + oy, bb.maxZ + oz,
+ bb.maxX + ox, bb.minY + oy, bb.minZ + oz,
+ bb.maxX + ox, bb.minY + oy, bb.maxZ + oz,
+ bb.maxX + ox, bb.maxY + oy, bb.minZ + oz,
+ bb.maxX + ox, bb.maxY + oy, bb.maxZ + oz,
+ };
+
+ // Use non-batching method without early failure
+ if (Baritone.settings().elytraRenderHitboxRaytraces.value) {
+ boolean clear = true;
+ for (int i = 0; i < 8; i++) {
+ final Vec3 s = new Vec3(src[i * 3], src[i * 3 + 1], src[i * 3 + 2]);
+ final Vec3 d = new Vec3(dst[i * 3], dst[i * 3 + 1], dst[i * 3 + 2]);
+ // Don't forward ignoreLava since the batch call doesn't care about it
+ if (!this.clearView(s, d, false)) {
+ clear = false;
+ }
+ }
+ return clear;
+ }
+
+ return this.context.raytrace(8, src, dst, NetherPathfinderContext.Visibility.ALL);
+ }
+
+ public boolean clearView(Vec3 start, Vec3 dest, boolean ignoreLava) {
+ final boolean clear;
+ if (!ignoreLava) {
+ // if start == dest then the cpp raytracer dies
+ clear = start.equals(dest) || this.context.raytrace(start, dest);
+ } else {
+ clear = ctx.world().clip(new ClipContext(start, dest, ClipContext.Block.COLLIDER, ClipContext.Fluid.ANY, ctx.player())).getType() == HitResult.Type.MISS;
+ }
+
+ if (Baritone.settings().elytraRenderRaytraces.value) {
+ (clear ? this.clearLines : this.blockedLines).add(new Pair<>(start, dest));
+ }
+ return clear;
+ }
+
+ private static FloatArrayList pitchesToSolveFor(final float goodPitch, final boolean desperate) {
+ final float minPitch = desperate ? -90 : Math.max(goodPitch - Baritone.settings().elytraPitchRange.value, -89);
+ final float maxPitch = desperate ? 90 : Math.min(goodPitch + Baritone.settings().elytraPitchRange.value, 89);
+
+ final FloatArrayList pitchValues = new FloatArrayList(fastCeil(maxPitch - minPitch) + 1);
+ for (float pitch = goodPitch; pitch <= maxPitch; pitch++) {
+ pitchValues.add(pitch);
+ }
+ for (float pitch = goodPitch - 1; pitch >= minPitch; pitch--) {
+ pitchValues.add(pitch);
+ }
+
+ return pitchValues;
+ }
+
+ @FunctionalInterface
+ private interface IntTriFunction {
+ T apply(int first, int second, int third);
+ }
+
+ private static final class IntTriple {
+ public final int first;
+ public final int second;
+ public final int third;
+
+ public IntTriple(int first, int second, int third) {
+ this.first = first;
+ this.second = second;
+ this.third = third;
+ }
+ }
+
+ private Pair solvePitch(final SolverContext context, final Vec3 goal, final int relaxation) {
+ final boolean desperate = relaxation == 2;
+ final float goodPitch = RotationUtils.calcRotationFromVec3d(context.start, goal, ctx.playerRotations()).getPitch();
+ final FloatArrayList pitches = pitchesToSolveFor(goodPitch, desperate);
+
+ final IntTriFunction
- 
- 
- 
- 
- 
- 
+ 
+ 
+ 
+ 
- 
- 
@@ -42,27 +46,34 @@
- 
+ 
+ 