instances = baritoneLoader.iterator();
provider = instances.next();
-
- settings = new Settings();
- SettingsUtil.readAndApply(settings);
}
public static IBaritoneProvider getProvider() {
diff --git a/src/api/java/baritone/api/IBaritone.java b/src/api/java/baritone/api/IBaritone.java
index 2c892d982..8c5de47ab 100644
--- a/src/api/java/baritone/api/IBaritone.java
+++ b/src/api/java/baritone/api/IBaritone.java
@@ -23,8 +23,10 @@ import baritone.api.cache.IWorldProvider;
import baritone.api.event.listener.IEventBus;
import baritone.api.pathing.calc.IPathingControlManager;
import baritone.api.process.*;
+import baritone.api.selection.ISelectionManager;
import baritone.api.utils.IInputOverrideHandler;
import baritone.api.utils.IPlayerContext;
+import baritone.api.utils.command.manager.ICommandManager;
/**
* @author Brady
@@ -32,15 +34,6 @@ import baritone.api.utils.IPlayerContext;
*/
public interface IBaritone {
- /**
- * Call as soon as Minecraft is ready, initializes all of the processes, behaviors, etc. This will
- * only effectively be ran once, any additional calls are redundant because the initialization state
- * is saved.
- *
- * Or whenever your overeager utility client wants.
- */
- void init();
-
/**
* @return The {@link IPathingBehavior} instance
* @see IPathingBehavior
@@ -128,6 +121,18 @@ public interface IBaritone {
*/
IEventBus getGameEventHandler();
+ /**
+ * @return The {@link ISelectionManager} instance
+ * @see ISelectionManager
+ */
+ ISelectionManager getSelectionManager();
+
+ /**
+ * @return The {@link ICommandManager} instance
+ * @see ICommandManager
+ */
+ ICommandManager getCommandManager();
+
/**
* Open click
*/
diff --git a/src/api/java/baritone/api/Settings.java b/src/api/java/baritone/api/Settings.java
index 1b47c4e33..d1bb68679 100644
--- a/src/api/java/baritone/api/Settings.java
+++ b/src/api/java/baritone/api/Settings.java
@@ -140,6 +140,13 @@ public final class Settings {
*/
public final Setting allowDiagonalDescend = new Setting<>(false);
+ /**
+ * Allow diagonal ascending
+ *
+ * Actually pretty safe, much safer than diagonal descend tbh
+ */
+ public final Setting allowDiagonalAscend = new Setting<>(false);
+
/**
* Allow mining the block directly beneath its feet
*
@@ -171,7 +178,9 @@ public final class Settings {
Blocks.CRAFTING_TABLE,
Blocks.FURNACE,
Blocks.CHEST,
- Blocks.TRAPPED_CHEST
+ Blocks.TRAPPED_CHEST,
+ Blocks.SIGN,
+ Blocks.WALL_SIGN
)));
/**
@@ -241,7 +250,12 @@ public final class Settings {
/**
* How many degrees to randomize the yaw every tick. Set to 0 to disable
*/
- public final Setting randomLooking = new Setting<>(2d);
+ public final Setting randomLooking113 = new Setting<>(2d);
+
+ /**
+ * How many degrees to randomize the pitch and yaw every tick. Set to 0 to disable
+ */
+ public final Setting randomLooking = new Setting<>(0.01d);
/**
* This is the big A* setting.
@@ -485,15 +499,20 @@ public final class Settings {
public final Setting chatControl = new Setting<>(true);
/**
- * A second override over chatControl to force it on
+ * Some clients like Impact try to force chatControl to off, so here's a second setting to do it anyway
*/
- public final Setting removePrefix = new Setting<>(false);
+ public final Setting chatControlAnyway = new Setting<>(false);
/**
* Render the path
*/
public final Setting renderPath = new Setting<>(true);
+ /**
+ * Render the path as a line instead of a frickin thingy
+ */
+ public final Setting renderPathAsLine = new Setting<>(false);
+
/**
* Render the goal
*/
@@ -594,10 +613,41 @@ public final class Settings {
public final Setting cachedChunksOpacity = new Setting<>(0.5f);
/**
- * Whether or not to use the "#" command prefix
+ * Whether or not to allow you to run Baritone commands with the prefix
*/
public final Setting prefixControl = new Setting<>(true);
+ /**
+ * The command prefix for chat control
+ */
+ public final Setting prefix = new Setting<>("#");
+
+ /**
+ * Use a short Baritone prefix [B] instead of [Baritone] when logging to chat
+ */
+ public final Setting shortBaritonePrefix = new Setting<>(false);
+
+ /**
+ * Echo commands to chat when they are run
+ */
+ public final Setting echoCommands = new Setting<>(true);
+
+ /**
+ * Censor coordinates in goals and block positions
+ */
+ public final Setting censorCoordinates = new Setting<>(false);
+
+ /**
+ * Censor arguments to ran commands, to hide, for example, coordinates to #goal
+ */
+ public final Setting censorRanCommands = new Setting<>(false);
+
+ /**
+ * Always prefer silk touch tools over regular tools. This will not sacrifice speed, but it will always prefer silk
+ * touch tools over other tools of the same speed. This includes always choosing ANY silk touch tool over your hand.
+ */
+ public final Setting preferSilkTouch = new Setting<>(false);
+
/**
* Don't stop walking forward when you need to break blocks in your way
*/
@@ -659,7 +709,12 @@ public final class Settings {
public final Setting exploreMaintainY = new Setting<>(64);
/**
- * Replant nether wart while farming
+ * Replant normal Crops while farming and leave cactus and sugarcane to regrow
+ */
+ public final Setting replantCrops = new Setting<>(true);
+
+ /**
+ * Replant nether wart while farming. This setting only has an effect when replantCrops is also enabled
*/
public final Setting replantNetherWart = new Setting<>(false);
@@ -721,11 +776,37 @@ public final class Settings {
*/
public final Setting breakCorrectBlockPenaltyMultiplier = new Setting<>(10d);
+ /**
+ * When this setting is true, build a schematic with the highest X coordinate being the origin, instead of the lowest
+ */
+ public final Setting schematicOrientationX = new Setting<>(false);
+
+ /**
+ * When this setting is true, build a schematic with the highest Y coordinate being the origin, instead of the lowest
+ */
+ public final Setting schematicOrientationY = new Setting<>(false);
+
+ /**
+ * When this setting is true, build a schematic with the highest Z coordinate being the origin, instead of the lowest
+ */
+ public final Setting schematicOrientationZ = new Setting<>(false);
+
+ /**
+ * Distance to scan every tick for updates. Expanding this beyond player reach distance (i.e. setting it to 6 or above)
+ * is only necessary in very large schematics where rescanning the whole thing is costly.
+ */
+ public final Setting builderTickScanRadius = new Setting<>(5);
+
/**
* While mining, should it also consider dropped items of the correct type as a pathing destination (as well as ore blocks)?
*/
public final Setting mineScanDroppedItems = new Setting<>(true);
+ /**
+ * Trim incorrect positions too far away, helps performance but hurts reliability in very large schematics
+ */
+ public final Setting distanceTrim = new Setting<>(true);
+
/**
* Cancel the current path if the goal has changed, and the path originally ended in the goal but doesn't anymore.
*
@@ -886,6 +967,51 @@ public final class Settings {
*/
public final Setting colorGoalBox = new Setting<>(Color.GREEN);
+ /**
+ * The color of the goal box when it's inverted
+ */
+ public final Setting colorInvertedGoalBox = new Setting<>(Color.RED);
+
+ /**
+ * The color of all selections
+ */
+ public final Setting colorSelection = new Setting<>(Color.CYAN);
+
+ /**
+ * The color of the selection pos 1
+ */
+ public final Setting colorSelectionPos1 = new Setting<>(Color.BLACK);
+
+ /**
+ * The color of the selection pos 2
+ */
+ public final Setting colorSelectionPos2 = new Setting<>(Color.ORANGE);
+
+ /**
+ * The opacity of the selection. 0 is completely transparent, 1 is completely opaque
+ */
+ public final Setting selectionOpacity = new Setting<>(.5f);
+
+ /**
+ * Line width of the goal when rendered, in pixels
+ */
+ public final Setting selectionLineWidth = new Setting<>(2F);
+
+ /**
+ * Render selections
+ */
+ public final Setting renderSelection = new Setting<>(true);
+
+ /**
+ * Ignore depth when rendering selections
+ */
+ public final Setting renderSelectionIgnoreDepth = new Setting<>(true);
+
+ /**
+ * Render selection corners
+ */
+ public final Setting renderSelectionCorners = new Setting<>(true);
+
/**
* A map of lowercase setting field names to their respective setting
@@ -900,6 +1026,7 @@ public final class Settings {
public final Map, Type> settingTypes;
public final class Setting {
+
public T value;
public final T defaultValue;
private String name;
@@ -982,10 +1109,10 @@ public final class Settings {
}
@SuppressWarnings("unchecked")
- public List> getAllValuesByType(Class klass) {
+ public List> getAllValuesByType(Class cla$$) {
List> result = new ArrayList<>();
for (Setting setting : allSettings) {
- if (setting.getValueClass().equals(klass)) {
+ if (setting.getValueClass().equals(cla$$)) {
result.add((Setting) setting);
}
}
diff --git a/src/api/java/baritone/api/accessor/IGuiScreen.java b/src/api/java/baritone/api/accessor/IGuiScreen.java
new file mode 100644
index 000000000..ba01e2755
--- /dev/null
+++ b/src/api/java/baritone/api/accessor/IGuiScreen.java
@@ -0,0 +1,25 @@
+/*
+ * 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.accessor;
+
+import java.net.URI;
+
+public interface IGuiScreen {
+
+ void openLink(URI url);
+}
diff --git a/src/api/java/baritone/api/accessor/IItemStack.java b/src/api/java/baritone/api/accessor/IItemStack.java
new file mode 100644
index 000000000..480c713fa
--- /dev/null
+++ b/src/api/java/baritone/api/accessor/IItemStack.java
@@ -0,0 +1,23 @@
+/*
+ * 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.accessor;
+
+public interface IItemStack {
+
+ int getBaritoneHash();
+}
diff --git a/src/api/java/baritone/api/behavior/IPathingBehavior.java b/src/api/java/baritone/api/behavior/IPathingBehavior.java
index 157774489..5444bb838 100644
--- a/src/api/java/baritone/api/behavior/IPathingBehavior.java
+++ b/src/api/java/baritone/api/behavior/IPathingBehavior.java
@@ -64,9 +64,17 @@ public interface IPathingBehavior extends IBehavior {
Goal getGoal();
/**
- * @return Whether or not a path is currently being executed.
+ * @return Whether or not a path is currently being executed. This will be false if there's currently a pause.
+ * @see #hasPath()
*/
- default boolean isPathing() {
+ boolean isPathing();
+
+ /**
+ * @return If there is a current path. Note that the path is not necessarily being executed, for example when there
+ * is a pause in effect.
+ * @see #isPathing()
+ */
+ default boolean hasPath() {
return getCurrent() != null;
}
diff --git a/src/api/java/baritone/api/cache/IWaypoint.java b/src/api/java/baritone/api/cache/IWaypoint.java
index 01df2a48b..ff2350993 100644
--- a/src/api/java/baritone/api/cache/IWaypoint.java
+++ b/src/api/java/baritone/api/cache/IWaypoint.java
@@ -17,12 +17,9 @@
package baritone.api.cache;
-import net.minecraft.util.math.BlockPos;
-import org.apache.commons.lang3.ArrayUtils;
+import baritone.api.utils.BetterBlockPos;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
+import java.util.*;
/**
* A marker for a position in the world.
@@ -60,7 +57,7 @@ public interface IWaypoint {
*
* @return The block position of this waypoint
*/
- BlockPos getLocation();
+ BetterBlockPos getLocation();
enum Tag {
@@ -92,20 +89,48 @@ public interface IWaypoint {
/**
* The names for the tag, anything that the tag can be referred to as.
*/
- private final String[] names;
+ public final String[] names;
Tag(String... names) {
this.names = names;
}
/**
- * Finds a tag from one of the names that could be used to identify said tag.
- *
- * @param name The name of the tag
- * @return The tag, if one is found, otherwise, {@code null}
+ * @return A name that can be passed to {@link #getByName(String)} to retrieve this tag
*/
- public static Tag fromString(String name) {
- return TAG_LIST.stream().filter(tag -> ArrayUtils.contains(tag.names, name.toLowerCase())).findFirst().orElse(null);
+ public String getName() {
+ return names[0];
+ }
+
+ /**
+ * Gets a tag by one of its names.
+ *
+ * @param name The name to search for.
+ * @return The tag, if found, or null.
+ */
+ public static Tag getByName(String name) {
+ for (Tag action : Tag.values()) {
+ for (String alias : action.names) {
+ if (alias.equalsIgnoreCase(name)) {
+ return action;
+ }
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * @return All tag names.
+ */
+ public static String[] getAllNames() {
+ Set names = new HashSet<>();
+
+ for (Tag tag : Tag.values()) {
+ names.addAll(Arrays.asList(tag.names));
+ }
+
+ return names.toArray(new String[0]);
}
}
}
diff --git a/src/api/java/baritone/api/cache/IWorldScanner.java b/src/api/java/baritone/api/cache/IWorldScanner.java
index caa44cbc6..325d4bd0e 100644
--- a/src/api/java/baritone/api/cache/IWorldScanner.java
+++ b/src/api/java/baritone/api/cache/IWorldScanner.java
@@ -17,6 +17,7 @@
package baritone.api.cache;
+import baritone.api.utils.BlockOptionalMetaLookup;
import baritone.api.utils.IPlayerContext;
import net.minecraft.block.Block;
import net.minecraft.util.math.BlockPos;
@@ -33,28 +34,53 @@ public interface IWorldScanner {
/**
* Scans the world, up to the specified max chunk radius, for the specified blocks.
*
- * @param ctx The {@link IPlayerContext} containing player and world info that the
- * scan is based upon
- * @param blocks The blocks to scan for
+ * @param ctx The {@link IPlayerContext} containing player and world info that the scan is based upon
+ * @param filter The blocks to scan for
* @param max The maximum number of blocks to scan before cutoff
- * @param yLevelThreshold If a block is found within this Y level, the current result will be
- * returned, if the value is negative, then this condition doesn't apply.
+ * @param yLevelThreshold If a block is found within this Y level, the current result will be returned, if the value
+ * is negative, then this condition doesn't apply.
* @param maxSearchRadius The maximum chunk search radius
* @return The matching block positions
*/
- List scanChunkRadius(IPlayerContext ctx, List blocks, int max, int yLevelThreshold, int maxSearchRadius);
+ List scanChunkRadius(IPlayerContext ctx, BlockOptionalMetaLookup filter, int max, int yLevelThreshold, int maxSearchRadius);
+
+ default List scanChunkRadius(IPlayerContext ctx, List filter, int max, int yLevelThreshold, int maxSearchRadius) {
+ return scanChunkRadius(ctx, new BlockOptionalMetaLookup(filter.toArray(new Block[0])), max, yLevelThreshold, maxSearchRadius);
+ }
/**
* Scans a single chunk for the specified blocks.
*
- * @param ctx The {@link IPlayerContext} containing player and world info that the
- * scan is based upon
+ * @param ctx The {@link IPlayerContext} containing player and world info that the scan is based upon
+ * @param filter The blocks to scan for
+ * @param pos The position of the target chunk
+ * @param max The maximum number of blocks to scan before cutoff
+ * @param yLevelThreshold If a block is found within this Y level, the current result will be returned, if the value
+ * is negative, then this condition doesn't apply.
+ * @return The matching block positions
+ */
+ List scanChunk(IPlayerContext ctx, BlockOptionalMetaLookup filter, ChunkPos pos, int max, int yLevelThreshold);
+
+ /**
+ * Scans a single chunk for the specified blocks.
+ *
+ * @param ctx The {@link IPlayerContext} containing player and world info that the scan is based upon
* @param blocks The blocks to scan for
* @param pos The position of the target chunk
* @param max The maximum number of blocks to scan before cutoff
- * @param yLevelThreshold If a block is found within this Y level, the current result will be
- * returned, if the value is negative, then this condition doesn't apply.
+ * @param yLevelThreshold If a block is found within this Y level, the current result will be returned, if the value
+ * is negative, then this condition doesn't apply.
* @return The matching block positions
*/
- List scanChunk(IPlayerContext ctx, List blocks, ChunkPos pos, int max, int yLevelThreshold);
+ default List scanChunk(IPlayerContext ctx, List blocks, ChunkPos pos, int max, int yLevelThreshold) {
+ return scanChunk(ctx, new BlockOptionalMetaLookup(blocks), pos, max, yLevelThreshold);
+ }
+
+ /**
+ * Repacks 40 chunks around the player.
+ *
+ * @param ctx The player context for that player.
+ * @return The number of chunks queued for repacking.
+ */
+ int repack(IPlayerContext ctx);
}
diff --git a/src/api/java/baritone/api/cache/Waypoint.java b/src/api/java/baritone/api/cache/Waypoint.java
index 2b9a7232b..9c4fbfbfc 100644
--- a/src/api/java/baritone/api/cache/Waypoint.java
+++ b/src/api/java/baritone/api/cache/Waypoint.java
@@ -17,7 +17,7 @@
package baritone.api.cache;
-import net.minecraft.util.math.BlockPos;
+import baritone.api.utils.BetterBlockPos;
import java.util.Date;
@@ -31,9 +31,9 @@ public class Waypoint implements IWaypoint {
private final String name;
private final Tag tag;
private final long creationTimestamp;
- private final BlockPos location;
+ private final BetterBlockPos location;
- public Waypoint(String name, Tag tag, BlockPos location) {
+ public Waypoint(String name, Tag tag, BetterBlockPos location) {
this(name, tag, location, System.currentTimeMillis());
}
@@ -46,7 +46,7 @@ public class Waypoint implements IWaypoint {
* @param location The waypoint location
* @param creationTimestamp When the waypoint was created
*/
- public Waypoint(String name, Tag tag, BlockPos location, long creationTimestamp) {
+ public Waypoint(String name, Tag tag, BetterBlockPos location, long creationTimestamp) {
this.name = name;
this.tag = tag;
this.location = location;
@@ -55,7 +55,7 @@ public class Waypoint implements IWaypoint {
@Override
public int hashCode() {
- return name.hashCode() + tag.hashCode() + location.hashCode(); //lol
+ return name.hashCode() ^ tag.hashCode() ^ location.hashCode() ^ Long.hashCode(creationTimestamp);
}
@Override
@@ -74,13 +74,18 @@ public class Waypoint implements IWaypoint {
}
@Override
- public BlockPos getLocation() {
+ public BetterBlockPos getLocation() {
return this.location;
}
@Override
public String toString() {
- return name + " " + location.toString() + " " + new Date(creationTimestamp).toString();
+ return String.format(
+ "%s %s %s",
+ name,
+ BetterBlockPos.from(location).toString(),
+ new Date(creationTimestamp).toString()
+ );
}
@Override
diff --git a/src/api/java/baritone/api/event/events/TabCompleteEvent.java b/src/api/java/baritone/api/event/events/TabCompleteEvent.java
new file mode 100644
index 000000000..fea1da292
--- /dev/null
+++ b/src/api/java/baritone/api/event/events/TabCompleteEvent.java
@@ -0,0 +1,53 @@
+/*
+ * 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.event.events.type.Cancellable;
+import baritone.api.event.events.type.Overrideable;
+
+/**
+ * @author LoganDark
+ */
+public abstract class TabCompleteEvent extends Cancellable {
+
+ public final Overrideable prefix;
+ public final Overrideable completions;
+
+ TabCompleteEvent(String prefix, String[] completions) {
+ this.prefix = new Overrideable<>(prefix);
+ this.completions = new Overrideable<>(completions);
+ }
+
+ public boolean wasModified() {
+ return prefix.wasModified() || completions.wasModified();
+ }
+
+ public static final class Pre extends TabCompleteEvent {
+
+ public Pre(String prefix) {
+ super(prefix, null);
+ }
+ }
+
+ public static final class Post extends TabCompleteEvent {
+
+ public Post(String prefix, String[] completions) {
+ super(prefix, completions);
+ }
+ }
+}
diff --git a/src/api/java/baritone/api/event/events/type/Overrideable.java b/src/api/java/baritone/api/event/events/type/Overrideable.java
new file mode 100644
index 000000000..cbad9b999
--- /dev/null
+++ b/src/api/java/baritone/api/event/events/type/Overrideable.java
@@ -0,0 +1,53 @@
+/*
+ * 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.type;
+
+/**
+ * @author LoganDark
+ */
+public class Overrideable {
+
+ private T value;
+ private boolean modified;
+
+ public Overrideable(T current) {
+ value = current;
+ }
+
+ public T get() {
+ return value;
+ }
+
+ public void set(T newValue) {
+ value = newValue;
+ modified = true;
+ }
+
+ public boolean wasModified() {
+ return modified;
+ }
+
+ @Override
+ public String toString() {
+ return String.format(
+ "Overrideable{modified=%b,value=%s}",
+ modified,
+ value.toString()
+ );
+ }
+}
diff --git a/src/api/java/baritone/api/event/listener/AbstractGameEventListener.java b/src/api/java/baritone/api/event/listener/AbstractGameEventListener.java
index 71045768a..e7d4dc292 100644
--- a/src/api/java/baritone/api/event/listener/AbstractGameEventListener.java
+++ b/src/api/java/baritone/api/event/listener/AbstractGameEventListener.java
@@ -39,6 +39,12 @@ public interface AbstractGameEventListener extends IGameEventListener {
@Override
default void onSendChatMessage(ChatEvent event) {}
+ @Override
+ default void onPreTabComplete(TabCompleteEvent.Pre event) {}
+
+ @Override
+ default void onPostTabComplete(TabCompleteEvent.Post event) {}
+
@Override
default void onChunkEvent(ChunkEvent event) {}
diff --git a/src/api/java/baritone/api/event/listener/IGameEventListener.java b/src/api/java/baritone/api/event/listener/IGameEventListener.java
index 93bdb7a61..44db8f62f 100644
--- a/src/api/java/baritone/api/event/listener/IGameEventListener.java
+++ b/src/api/java/baritone/api/event/listener/IGameEventListener.java
@@ -56,6 +56,21 @@ public interface IGameEventListener {
*/
void onSendChatMessage(ChatEvent event);
+ /**
+ * Runs whenever the client player tries to tab complete in chat.
+ *
+ * @param event The event
+ */
+ void onPreTabComplete(TabCompleteEvent.Pre event);
+
+ /**
+ * Runs whenever the client player tries to tab complete in chat once completions have been recieved from the
+ * server. This will only be called if the {@link TabCompleteEvent#cancel()} method was not called.
+ *
+ * @param event The event
+ */
+ void onPostTabComplete(TabCompleteEvent.Post event);
+
/**
* Runs before and after whenever a chunk is either loaded, unloaded, or populated.
*
diff --git a/src/api/java/baritone/api/pathing/goals/GoalBlock.java b/src/api/java/baritone/api/pathing/goals/GoalBlock.java
index 89dd63048..c85e5cadd 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.SettingsUtil;
import baritone.api.utils.interfaces.IGoalRenderPos;
import net.minecraft.util.math.BlockPos;
@@ -67,7 +68,12 @@ public class GoalBlock implements Goal, IGoalRenderPos {
@Override
public String toString() {
- return "GoalBlock{x=" + x + ",y=" + y + ",z=" + z + "}";
+ return String.format(
+ "GoalBlock{x=%s,y=%s,z=%s}",
+ SettingsUtil.maybeCensor(x),
+ SettingsUtil.maybeCensor(y),
+ SettingsUtil.maybeCensor(z)
+ );
}
/**
diff --git a/src/api/java/baritone/api/pathing/goals/GoalGetToBlock.java b/src/api/java/baritone/api/pathing/goals/GoalGetToBlock.java
index fb2a07aaf..8d6fdcb30 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.SettingsUtil;
import baritone.api.utils.interfaces.IGoalRenderPos;
import net.minecraft.util.math.BlockPos;
@@ -61,6 +62,11 @@ public class GoalGetToBlock implements Goal, IGoalRenderPos {
@Override
public String toString() {
- return "GoalGetToBlock{x=" + x + ",y=" + y + ",z=" + z + "}";
+ return String.format(
+ "GoalGetToBlock{x=%s,y=%s,z=%s}",
+ SettingsUtil.maybeCensor(x),
+ SettingsUtil.maybeCensor(y),
+ SettingsUtil.maybeCensor(z)
+ );
}
}
diff --git a/src/api/java/baritone/api/pathing/goals/GoalInverted.java b/src/api/java/baritone/api/pathing/goals/GoalInverted.java
new file mode 100644
index 000000000..197369241
--- /dev/null
+++ b/src/api/java/baritone/api/pathing/goals/GoalInverted.java
@@ -0,0 +1,52 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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.pathing.goals;
+
+/**
+ * Invert any goal.
+ *
+ * In the old chat control system, #invert just tried to pick a {@link GoalRunAway} that effectively inverted the
+ * current goal. This goal just reverses the heuristic to act as a TRUE invert. Inverting a Y level? Baritone tries to
+ * get away from that Y level. Inverting a GoalBlock? Baritone will try to make distance whether it's in the X, Y or Z
+ * directions. And of course, you can always invert a GoalXZ.
+ *
+ * @author LoganDark
+ */
+public class GoalInverted implements Goal {
+
+ public final Goal origin;
+
+ public GoalInverted(Goal origin) {
+ this.origin = origin;
+ }
+
+ @Override
+ public boolean isInGoal(int x, int y, int z) {
+ return false;
+ }
+
+ @Override
+ public double heuristic(int x, int y, int z) {
+ return -origin.heuristic(x, y, z);
+ }
+
+ @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 4f75aba72..73d64ed9f 100644
--- a/src/api/java/baritone/api/pathing/goals/GoalNear.java
+++ b/src/api/java/baritone/api/pathing/goals/GoalNear.java
@@ -17,10 +17,12 @@
package baritone.api.pathing.goals;
+import baritone.api.utils.SettingsUtil;
import baritone.api.utils.interfaces.IGoalRenderPos;
import net.minecraft.util.math.BlockPos;
public class GoalNear implements Goal, IGoalRenderPos {
+
private final int x;
private final int y;
private final int z;
@@ -56,11 +58,12 @@ public class GoalNear implements Goal, IGoalRenderPos {
@Override
public String toString() {
- return "GoalNear{" +
- "x=" + x +
- ", y=" + y +
- ", z=" + z +
- ", rangeSq=" + rangeSq +
- "}";
+ return String.format(
+ "GoalNear{x=%s, y=%s, z=%s, rangeSq=%d}",
+ SettingsUtil.maybeCensor(x),
+ SettingsUtil.maybeCensor(y),
+ SettingsUtil.maybeCensor(z),
+ rangeSq
+ );
}
}
diff --git a/src/api/java/baritone/api/pathing/goals/GoalRunAway.java b/src/api/java/baritone/api/pathing/goals/GoalRunAway.java
index 3f4a02de1..a1a153780 100644
--- a/src/api/java/baritone/api/pathing/goals/GoalRunAway.java
+++ b/src/api/java/baritone/api/pathing/goals/GoalRunAway.java
@@ -17,6 +17,7 @@
package baritone.api.pathing.goals;
+import baritone.api.utils.SettingsUtil;
import net.minecraft.util.math.BlockPos;
import java.util.Arrays;
@@ -82,7 +83,11 @@ public class GoalRunAway implements Goal {
@Override
public String toString() {
if (maintainY != null) {
- return "GoalRunAwayFromMaintainY y=" + maintainY + ", " + Arrays.asList(from);
+ return String.format(
+ "GoalRunAwayFromMaintainY y=%s, %s",
+ SettingsUtil.maybeCensor(maintainY),
+ Arrays.asList(from)
+ );
} else {
return "GoalRunAwayFrom" + Arrays.asList(from);
}
diff --git a/src/api/java/baritone/api/pathing/goals/GoalStrictDirection.java b/src/api/java/baritone/api/pathing/goals/GoalStrictDirection.java
index 24ae385ac..b48a029ad 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.SettingsUtil;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.math.BlockPos;
@@ -24,6 +25,7 @@ import net.minecraft.util.math.BlockPos;
* Dig a tunnel in a certain direction, but if you have to deviate from the path, go back to where you started
*/
public class GoalStrictDirection implements Goal {
+
public final int x;
public final int y;
public final int z;
@@ -64,12 +66,13 @@ public class GoalStrictDirection implements Goal {
@Override
public String toString() {
- return "GoalStrictDirection{" +
- "x=" + x +
- ", y=" + y +
- ", z=" + z +
- ", dx=" + dx +
- ", dz=" + dz +
- "}";
+ return String.format(
+ "GoalStrictDirection{x=%s, y=%s, z=%s, dx=%s, dz=%s}",
+ SettingsUtil.maybeCensor(x),
+ SettingsUtil.maybeCensor(y),
+ SettingsUtil.maybeCensor(z),
+ SettingsUtil.maybeCensor(dx),
+ SettingsUtil.maybeCensor(dz)
+ );
}
}
diff --git a/src/api/java/baritone/api/pathing/goals/GoalTwoBlocks.java b/src/api/java/baritone/api/pathing/goals/GoalTwoBlocks.java
index f1026ab50..27be981e4 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.SettingsUtil;
import baritone.api.utils.interfaces.IGoalRenderPos;
import net.minecraft.util.math.BlockPos;
@@ -73,6 +74,11 @@ public class GoalTwoBlocks implements Goal, IGoalRenderPos {
@Override
public String toString() {
- return "GoalTwoBlocks{x=" + x + ",y=" + y + ",z=" + z + "}";
+ return String.format(
+ "GoalTwoBlocks{x=%s,y=%s,z=%s}",
+ SettingsUtil.maybeCensor(x),
+ SettingsUtil.maybeCensor(y),
+ SettingsUtil.maybeCensor(z)
+ );
}
}
diff --git a/src/api/java/baritone/api/pathing/goals/GoalXZ.java b/src/api/java/baritone/api/pathing/goals/GoalXZ.java
index 7f8d16abe..63d39cd78 100644
--- a/src/api/java/baritone/api/pathing/goals/GoalXZ.java
+++ b/src/api/java/baritone/api/pathing/goals/GoalXZ.java
@@ -18,6 +18,8 @@
package baritone.api.pathing.goals;
import baritone.api.BaritoneAPI;
+import baritone.api.utils.BetterBlockPos;
+import baritone.api.utils.SettingsUtil;
import net.minecraft.util.math.MathHelper;
import net.minecraft.util.math.Vec3d;
@@ -45,6 +47,11 @@ public class GoalXZ implements Goal {
this.z = z;
}
+ public GoalXZ(BetterBlockPos pos) {
+ this.x = pos.x;
+ this.z = pos.z;
+ }
+
@Override
public boolean isInGoal(int x, int y, int z) {
return x == this.x && z == this.z;
@@ -59,7 +66,11 @@ public class GoalXZ implements Goal {
@Override
public String toString() {
- return "GoalXZ{x=" + x + ",z=" + z + "}";
+ return String.format(
+ "GoalXZ{x=%s,z=%s}",
+ SettingsUtil.maybeCensor(x),
+ SettingsUtil.maybeCensor(z)
+ );
}
public static double calculate(double xDiff, double zDiff) {
@@ -87,7 +98,7 @@ public class GoalXZ implements Goal {
float theta = (float) Math.toRadians(yaw);
double x = origin.x - MathHelper.sin(theta) * distance;
double z = origin.z + MathHelper.cos(theta) * distance;
- return new GoalXZ((int) x, (int) z);
+ return new GoalXZ(MathHelper.floor(x), MathHelper.floor(z));
}
public int getX() {
diff --git a/src/api/java/baritone/api/pathing/goals/GoalYLevel.java b/src/api/java/baritone/api/pathing/goals/GoalYLevel.java
index 9add7176a..603ef9bd1 100644
--- a/src/api/java/baritone/api/pathing/goals/GoalYLevel.java
+++ b/src/api/java/baritone/api/pathing/goals/GoalYLevel.java
@@ -18,6 +18,7 @@
package baritone.api.pathing.goals;
import baritone.api.pathing.movement.ActionCosts;
+import baritone.api.utils.SettingsUtil;
/**
* Useful for mining (getting to diamond / iron level)
@@ -59,6 +60,9 @@ public class GoalYLevel implements Goal, ActionCosts {
@Override
public String toString() {
- return "GoalYLevel{y=" + level + "}";
+ return String.format(
+ "GoalYLevel{y=%s}",
+ SettingsUtil.maybeCensor(level)
+ );
}
}
diff --git a/src/api/java/baritone/api/process/IBuilderProcess.java b/src/api/java/baritone/api/process/IBuilderProcess.java
index 90aba4eaf..efd96d9fa 100644
--- a/src/api/java/baritone/api/process/IBuilderProcess.java
+++ b/src/api/java/baritone/api/process/IBuilderProcess.java
@@ -18,11 +18,13 @@
package baritone.api.process;
import baritone.api.utils.ISchematic;
+import net.minecraft.block.state.IBlockState;
import net.minecraft.client.Minecraft;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.Vec3i;
import java.io.File;
+import java.util.List;
/**
* @author Brady
@@ -58,7 +60,16 @@ public interface IBuilderProcess extends IBaritoneProcess {
void pause();
+ boolean isPaused();
+
void resume();
void clearArea(BlockPos corner1, BlockPos corner2);
+
+ /**
+ * @return A list of block states that are estimated to be placeable by this builder process. You can use this in
+ * schematics, for example, to pick a state that the builder process will be happy with, because any variation will
+ * cause it to give up. This is updated every tick, but only while the builder process is active.
+ */
+ List getApproxPlaceable();
}
diff --git a/src/api/java/baritone/api/process/IExploreProcess.java b/src/api/java/baritone/api/process/IExploreProcess.java
index 811a509f0..4950d31d5 100644
--- a/src/api/java/baritone/api/process/IExploreProcess.java
+++ b/src/api/java/baritone/api/process/IExploreProcess.java
@@ -20,6 +20,7 @@ package baritone.api.process;
import java.nio.file.Path;
public interface IExploreProcess extends IBaritoneProcess {
+
void explore(int centerX, int centerZ);
void applyJsonFilter(Path path, boolean invert) throws Exception;
diff --git a/src/api/java/baritone/api/process/IFarmProcess.java b/src/api/java/baritone/api/process/IFarmProcess.java
index c9234a24a..6ced16fba 100644
--- a/src/api/java/baritone/api/process/IFarmProcess.java
+++ b/src/api/java/baritone/api/process/IFarmProcess.java
@@ -18,5 +18,6 @@
package baritone.api.process;
public interface IFarmProcess extends IBaritoneProcess {
+
void farm();
}
diff --git a/src/api/java/baritone/api/process/IMineProcess.java b/src/api/java/baritone/api/process/IMineProcess.java
index 7ebabc9cb..9cd76a09a 100644
--- a/src/api/java/baritone/api/process/IMineProcess.java
+++ b/src/api/java/baritone/api/process/IMineProcess.java
@@ -17,8 +17,12 @@
package baritone.api.process;
+import baritone.api.utils.BlockOptionalMeta;
+import baritone.api.utils.BlockOptionalMetaLookup;
import net.minecraft.block.Block;
+import java.util.stream.Stream;
+
/**
* @author Brady
* @since 9/23/2018
@@ -28,9 +32,9 @@ public interface IMineProcess extends IBaritoneProcess {
/**
* Begin to search for and mine the specified blocks until
* the number of specified items to get from the blocks that
- * are mined. This is based on the first target block to mine.
+ * are mined.
*
- * @param quantity The number of items to get from blocks mined
+ * @param quantity The total number of items to get
* @param blocks The blocks to mine
*/
void mineByName(int quantity, String... blocks);
@@ -41,9 +45,18 @@ public interface IMineProcess extends IBaritoneProcess {
* are mined. This is based on the first target block to mine.
*
* @param quantity The number of items to get from blocks mined
- * @param blocks The blocks to mine
+ * @param filter The blocks to mine
*/
- void mine(int quantity, Block... blocks);
+ void mine(int quantity, BlockOptionalMetaLookup filter);
+
+ /**
+ * Begin to search for and mine the specified blocks.
+ *
+ * @param filter The blocks to mine
+ */
+ default void mine(BlockOptionalMetaLookup filter) {
+ mine(0, filter);
+ }
/**
* Begin to search for and mine the specified blocks.
@@ -54,6 +67,38 @@ public interface IMineProcess extends IBaritoneProcess {
mineByName(0, blocks);
}
+ /**
+ * Begin to search for and mine the specified blocks.
+ *
+ * @param boms The blocks to mine
+ */
+ default void mine(int quantity, BlockOptionalMeta... boms) {
+ mine(quantity, new BlockOptionalMetaLookup(boms));
+ }
+
+ /**
+ * Begin to search for and mine the specified blocks.
+ *
+ * @param boms The blocks to mine
+ */
+ default void mine(BlockOptionalMeta... boms) {
+ mine(0, boms);
+ }
+
+ /**
+ * Begin to search for and mine the specified blocks.
+ *
+ * @param quantity The total number of items to get
+ * @param blocks The blocks to mine
+ */
+ default void mine(int quantity, Block... blocks) {
+ mine(quantity, new BlockOptionalMetaLookup(
+ Stream.of(blocks)
+ .map(BlockOptionalMeta::new)
+ .toArray(BlockOptionalMeta[]::new)
+ ));
+ }
+
/**
* Begin to search for and mine the specified blocks.
*
diff --git a/src/api/java/baritone/api/schematic/AbstractSchematic.java b/src/api/java/baritone/api/schematic/AbstractSchematic.java
new file mode 100644
index 000000000..7a24e803f
--- /dev/null
+++ b/src/api/java/baritone/api/schematic/AbstractSchematic.java
@@ -0,0 +1,48 @@
+/*
+ * 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;
+
+import baritone.api.utils.ISchematic;
+
+public abstract class AbstractSchematic implements ISchematic {
+
+ protected int x;
+ protected int y;
+ protected int z;
+
+ public AbstractSchematic(int x, int y, int z) {
+ this.x = x;
+ this.y = y;
+ this.z = z;
+ }
+
+ @Override
+ public int widthX() {
+ return x;
+ }
+
+ @Override
+ public int heightY() {
+ return y;
+ }
+
+ @Override
+ public int lengthZ() {
+ return z;
+ }
+}
diff --git a/src/api/java/baritone/api/schematic/CompositeSchematic.java b/src/api/java/baritone/api/schematic/CompositeSchematic.java
new file mode 100644
index 000000000..21df29b4d
--- /dev/null
+++ b/src/api/java/baritone/api/schematic/CompositeSchematic.java
@@ -0,0 +1,75 @@
+/*
+ * 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;
+
+import baritone.api.utils.ISchematic;
+import net.minecraft.block.state.IBlockState;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class CompositeSchematic extends AbstractSchematic {
+
+ private final List schematics;
+ private CompositeSchematicEntry[] schematicArr;
+
+ private void recalcArr() {
+ schematicArr = schematics.toArray(new CompositeSchematicEntry[0]);
+ for (CompositeSchematicEntry entry : schematicArr) {
+ this.x = Math.max(x, entry.x + entry.schematic.widthX());
+ this.y = Math.max(y, entry.y + entry.schematic.heightY());
+ this.z = Math.max(z, entry.z + entry.schematic.lengthZ());
+ }
+ }
+
+ public CompositeSchematic(int x, int y, int z) {
+ super(x, y, z);
+ schematics = new ArrayList<>();
+ recalcArr();
+ }
+
+ public void put(ISchematic extra, int x, int y, int z) {
+ schematics.add(new CompositeSchematicEntry(extra, x, y, z));
+ recalcArr();
+ }
+
+ private CompositeSchematicEntry getSchematic(int x, int y, int z, IBlockState currentState) {
+ for (CompositeSchematicEntry entry : schematicArr) {
+ if (x >= entry.x && y >= entry.y && z >= entry.z &&
+ entry.schematic.inSchematic(x - entry.x, y - entry.y, z - entry.z, currentState)) {
+ return entry;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public boolean inSchematic(int x, int y, int z, IBlockState currentState) {
+ CompositeSchematicEntry entry = getSchematic(x, y, z, currentState);
+ return entry != null && entry.schematic.inSchematic(x - entry.x, y - entry.y, z - entry.z, currentState);
+ }
+
+ @Override
+ public IBlockState desiredState(int x, int y, int z, IBlockState current, List approxPlaceable) {
+ CompositeSchematicEntry entry = getSchematic(x, y, z, current);
+ if (entry == null) {
+ throw new IllegalStateException("couldn't find schematic for this position");
+ }
+ return entry.schematic.desiredState(x - entry.x, y - entry.y, z - entry.z, current, approxPlaceable);
+ }
+}
diff --git a/src/api/java/baritone/api/schematic/CompositeSchematicEntry.java b/src/api/java/baritone/api/schematic/CompositeSchematicEntry.java
new file mode 100644
index 000000000..a26f356bf
--- /dev/null
+++ b/src/api/java/baritone/api/schematic/CompositeSchematicEntry.java
@@ -0,0 +1,35 @@
+/*
+ * 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;
+
+import baritone.api.utils.ISchematic;
+
+public class CompositeSchematicEntry {
+
+ public final ISchematic schematic;
+ public final int x;
+ public final int y;
+ public final int z;
+
+ public CompositeSchematicEntry(ISchematic schematic, int x, int y, int z) {
+ this.schematic = schematic;
+ this.x = x;
+ this.y = y;
+ this.z = z;
+ }
+}
diff --git a/src/api/java/baritone/api/schematic/FillSchematic.java b/src/api/java/baritone/api/schematic/FillSchematic.java
new file mode 100644
index 000000000..aaaeb5dd1
--- /dev/null
+++ b/src/api/java/baritone/api/schematic/FillSchematic.java
@@ -0,0 +1,53 @@
+/*
+ * 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;
+
+import baritone.api.utils.BlockOptionalMeta;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.init.Blocks;
+
+import java.util.List;
+
+public class FillSchematic extends AbstractSchematic {
+
+ private final BlockOptionalMeta bom;
+
+ public FillSchematic(int x, int y, int z, BlockOptionalMeta bom) {
+ super(x, y, z);
+ this.bom = bom;
+ }
+
+ public BlockOptionalMeta getBom() {
+ return bom;
+ }
+
+ @Override
+ public IBlockState desiredState(int x, int y, int z, IBlockState current, List approxPlaceable) {
+ if (bom.matches(current)) {
+ return current;
+ } else if (current.getBlock() != Blocks.AIR) {
+ return Blocks.AIR.getDefaultState();
+ }
+ for (IBlockState placeable : approxPlaceable) {
+ if (bom.matches(placeable)) {
+ return placeable;
+ }
+ }
+ return bom.getAnyBlockState();
+ }
+}
diff --git a/src/api/java/baritone/api/schematic/MaskSchematic.java b/src/api/java/baritone/api/schematic/MaskSchematic.java
new file mode 100644
index 000000000..fa9b81269
--- /dev/null
+++ b/src/api/java/baritone/api/schematic/MaskSchematic.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.schematic;
+
+import baritone.api.utils.ISchematic;
+import net.minecraft.block.state.IBlockState;
+
+import java.util.List;
+
+public abstract class MaskSchematic extends AbstractSchematic {
+
+ private final ISchematic schematic;
+
+ public MaskSchematic(ISchematic schematic) {
+ super(schematic.widthX(), schematic.heightY(), schematic.lengthZ());
+ this.schematic = schematic;
+ }
+
+ protected abstract boolean partOfMask(int x, int y, int z, IBlockState currentState);
+
+ @Override
+ public boolean inSchematic(int x, int y, int z, IBlockState currentState) {
+ return schematic.inSchematic(x, y, z, currentState) && partOfMask(x, y, z, currentState);
+ }
+
+ @Override
+ public IBlockState desiredState(int x, int y, int z, IBlockState current, List approxPlaceable) {
+ return schematic.desiredState(x, y, z, current, approxPlaceable);
+ }
+}
diff --git a/src/api/java/baritone/api/schematic/ReplaceSchematic.java b/src/api/java/baritone/api/schematic/ReplaceSchematic.java
new file mode 100644
index 000000000..988cfd7f1
--- /dev/null
+++ b/src/api/java/baritone/api/schematic/ReplaceSchematic.java
@@ -0,0 +1,42 @@
+/*
+ * 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;
+
+import baritone.api.utils.BlockOptionalMetaLookup;
+import baritone.api.utils.ISchematic;
+import net.minecraft.block.state.IBlockState;
+
+public class ReplaceSchematic extends MaskSchematic {
+
+ private final BlockOptionalMetaLookup filter;
+ private final Boolean[][][] cache;
+
+ public ReplaceSchematic(ISchematic schematic, BlockOptionalMetaLookup filter) {
+ super(schematic);
+ this.filter = filter;
+ this.cache = new Boolean[widthX()][heightY()][lengthZ()];
+ }
+
+ @Override
+ protected boolean partOfMask(int x, int y, int z, IBlockState currentState) {
+ if (cache[x][y][z] == null) {
+ cache[x][y][z] = filter.has(currentState);
+ }
+ return cache[x][y][z];
+ }
+}
diff --git a/src/api/java/baritone/api/schematic/ShellSchematic.java b/src/api/java/baritone/api/schematic/ShellSchematic.java
new file mode 100644
index 000000000..4ead61b6c
--- /dev/null
+++ b/src/api/java/baritone/api/schematic/ShellSchematic.java
@@ -0,0 +1,33 @@
+/*
+ * 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;
+
+import baritone.api.utils.ISchematic;
+import net.minecraft.block.state.IBlockState;
+
+public class ShellSchematic extends MaskSchematic {
+
+ public ShellSchematic(ISchematic schematic) {
+ super(schematic);
+ }
+
+ @Override
+ protected boolean partOfMask(int x, int y, int z, IBlockState currentState) {
+ return x == 0 || y == 0 || z == 0 || x == widthX() - 1 || y == heightY() - 1 || z == lengthZ() - 1;
+ }
+}
diff --git a/src/api/java/baritone/api/schematic/WallsSchematic.java b/src/api/java/baritone/api/schematic/WallsSchematic.java
new file mode 100644
index 000000000..e05de1e70
--- /dev/null
+++ b/src/api/java/baritone/api/schematic/WallsSchematic.java
@@ -0,0 +1,33 @@
+/*
+ * 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;
+
+import baritone.api.utils.ISchematic;
+import net.minecraft.block.state.IBlockState;
+
+public class WallsSchematic extends MaskSchematic {
+
+ public WallsSchematic(ISchematic schematic) {
+ super(schematic);
+ }
+
+ @Override
+ protected boolean partOfMask(int x, int y, int z, IBlockState currentState) {
+ return x == 0 || z == 0 || x == widthX() - 1 || z == lengthZ() - 1;
+ }
+}
diff --git a/src/api/java/baritone/api/selection/ISelection.java b/src/api/java/baritone/api/selection/ISelection.java
new file mode 100644
index 000000000..59651feb0
--- /dev/null
+++ b/src/api/java/baritone/api/selection/ISelection.java
@@ -0,0 +1,91 @@
+/*
+ * 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.selection;
+
+import baritone.api.utils.BetterBlockPos;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.AxisAlignedBB;
+import net.minecraft.util.math.Vec3i;
+
+/**
+ * A selection is an immutable object representing the current selection. The selection is commonly used for certain
+ * types of build commands, however it can be used for anything.
+ */
+public interface ISelection {
+
+ /**
+ * @return The first corner of this selection. This is meant to preserve the user's original first corner.
+ */
+ BetterBlockPos pos1();
+
+ /**
+ * @return The second corner of this selection. This is meant to preserve the user's original second corner.
+ */
+ BetterBlockPos pos2();
+
+ /**
+ * @return The {@link BetterBlockPos} with the lowest x, y, and z position in the selection.
+ */
+ BetterBlockPos min();
+
+ /**
+ * @return The opposite corner from the {@link #min()}.
+ */
+ BetterBlockPos max();
+
+ /**
+ * @return The size of this ISelection.
+ */
+ Vec3i size();
+
+ /**
+ * @return An {@link AxisAlignedBB} encompassing all blocks in this selection.
+ */
+ AxisAlignedBB aabb();
+
+ /**
+ * Returns a new {@link ISelection} expanded in the specified direction by the specified number of blocks.
+ *
+ * @param direction The direction to expand the selection.
+ * @param blocks How many blocks to expand it.
+ * @return A new selection, expanded as specified.
+ */
+ ISelection expand(EnumFacing direction, int blocks);
+
+ /**
+ * Returns a new {@link ISelection} contracted in the specified direction by the specified number of blocks.
+ *
+ * Note that, for example, if the direction specified is UP, the bottom of the selection will be shifted up. If it
+ * is DOWN, the top of the selection will be shifted down.
+ *
+ * @param direction The direction to contract the selection.
+ * @param blocks How many blocks to contract it.
+ * @return A new selection, contracted as specified.
+ */
+ ISelection contract(EnumFacing direction, int blocks);
+
+ /**
+ * Returns a new {@link ISelection} shifted in the specified direction by the specified number of blocks. This moves
+ * the whole selection.
+ *
+ * @param direction The direction to shift the selection.
+ * @param blocks How many blocks to shift it.
+ * @return A new selection, shifted as specified.
+ */
+ ISelection shift(EnumFacing direction, int blocks);
+}
diff --git a/src/api/java/baritone/api/selection/ISelectionManager.java b/src/api/java/baritone/api/selection/ISelectionManager.java
new file mode 100644
index 000000000..de5ee2887
--- /dev/null
+++ b/src/api/java/baritone/api/selection/ISelectionManager.java
@@ -0,0 +1,116 @@
+/*
+ * 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.selection;
+
+import baritone.api.utils.BetterBlockPos;
+import net.minecraft.util.EnumFacing;
+
+/**
+ * The selection manager handles setting Baritone's selections. You can set the selection here, as well as retrieving
+ * the current selection.
+ */
+public interface ISelectionManager {
+
+ /**
+ * Adds a new selection. The added selection is returned.
+ *
+ * @param selection The new selection to add.
+ */
+ ISelection addSelection(ISelection selection);
+
+ /**
+ * Adds a new {@link ISelection} constructed from the given block positions. The new selection is returned.
+ *
+ * @param pos1 One corner of the selection
+ * @param pos2 The new corner of the selection
+ */
+ ISelection addSelection(BetterBlockPos pos1, BetterBlockPos pos2);
+
+ /**
+ * Removes the selection from the current selections.
+ *
+ * @param selection The selection to remove.
+ * @return The removed selection.
+ */
+ ISelection removeSelection(ISelection selection);
+
+ /**
+ * Removes all selections.
+ *
+ * @return The selections that were removed, sorted from oldest to newest..
+ */
+ ISelection[] removeAllSelections();
+
+ /**
+ * @return The current selections, sorted from oldest to newest.
+ */
+ ISelection[] getSelections();
+
+ /**
+ * For anything expecting only one selection, this method is provided. However, to enforce multi-selection support,
+ * this method will only return a selection if there is ONLY one.
+ *
+ * @return The only selection, or null if there isn't only one.
+ */
+ ISelection getOnlySelection();
+
+ /**
+ * This method will always return the last selection. ONLY use this if you want to, for example, modify the most
+ * recent selection based on user input. ALWAYS use {@link #getOnlySelection()} or, ideally,
+ * {@link #getSelections()} for retrieving the content of selections.
+ *
+ * @return The last selection, or null if it doesn't exist.
+ */
+ ISelection getLastSelection();
+
+ /**
+ * Replaces the specified {@link ISelection} with one expanded in the specified direction by the specified number of
+ * blocks. Returns the new selection.
+ *
+ * @param selection The selection to expand.
+ * @param direction The direction to expand the selection.
+ * @param blocks How many blocks to expand it.
+ * @return The new selection, expanded as specified.
+ */
+ ISelection expand(ISelection selection, EnumFacing direction, int blocks);
+
+ /**
+ * Replaces the specified {@link ISelection} with one contracted in the specified direction by the specified number
+ * of blocks.
+ *
+ * Note that, for example, if the direction specified is UP, the bottom of the selection will be shifted up. If it
+ * is DOWN, the top of the selection will be shifted down.
+ *
+ * @param selection The selection to contract.
+ * @param direction The direction to contract the selection.
+ * @param blocks How many blocks to contract it.
+ * @return The new selection, contracted as specified.
+ */
+ ISelection contract(ISelection selection, EnumFacing direction, int blocks);
+
+ /**
+ * Replaces the specified {@link ISelection} with one shifted in the specified direction by the specified number of
+ * blocks. This moves the whole selection.
+ *
+ * @param selection The selection to shift.
+ * @param direction The direction to shift the selection.
+ * @param blocks How many blocks to shift it.
+ * @return The new selection, shifted as specified.
+ */
+ ISelection shift(ISelection selection, EnumFacing direction, int blocks);
+}
diff --git a/src/api/java/baritone/api/utils/BetterBlockPos.java b/src/api/java/baritone/api/utils/BetterBlockPos.java
index 3b94a8339..a9b02445b 100644
--- a/src/api/java/baritone/api/utils/BetterBlockPos.java
+++ b/src/api/java/baritone/api/utils/BetterBlockPos.java
@@ -22,6 +22,8 @@ import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.MathHelper;
import net.minecraft.util.math.Vec3i;
+import javax.annotation.Nonnull;
+
/**
* A better BlockPos that has fewer hash collisions (and slightly more performant offsets)
*
@@ -32,6 +34,9 @@ import net.minecraft.util.math.Vec3i;
* @author leijurv
*/
public final class BetterBlockPos extends BlockPos {
+
+ public static final BetterBlockPos ORIGIN = new BetterBlockPos(0, 0, 0);
+
public final int x;
public final int y;
public final int z;
@@ -51,6 +56,20 @@ public final class BetterBlockPos extends BlockPos {
this(pos.getX(), pos.getY(), pos.getZ());
}
+ /**
+ * Like constructor but returns null if pos is null, good if you just need to possibly censor coordinates
+ *
+ * @param pos The BlockPos, possibly null, to convert
+ * @return A BetterBlockPos or null if pos was null
+ */
+ public static BetterBlockPos from(BlockPos pos) {
+ if (pos == null) {
+ return null;
+ }
+
+ return new BetterBlockPos(pos);
+ }
+
@Override
public int hashCode() {
return (int) longHash(x, y, z);
@@ -182,4 +201,15 @@ public final class BetterBlockPos extends BlockPos {
public BetterBlockPos west(int amt) {
return amt == 0 ? this : new BetterBlockPos(x - amt, y, z);
}
+
+ @Override
+ @Nonnull
+ public String toString() {
+ return String.format(
+ "BetterBlockPos{x=%s,y=%s,z=%s}",
+ SettingsUtil.maybeCensor(x),
+ SettingsUtil.maybeCensor(y),
+ SettingsUtil.maybeCensor(z)
+ );
+ }
}
diff --git a/src/api/java/baritone/api/utils/BlockOptionalMeta.java b/src/api/java/baritone/api/utils/BlockOptionalMeta.java
new file mode 100644
index 000000000..9a1891c8c
--- /dev/null
+++ b/src/api/java/baritone/api/utils/BlockOptionalMeta.java
@@ -0,0 +1,294 @@
+/*
+ * 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 baritone.api.accessor.IItemStack;
+import com.google.common.collect.ImmutableSet;
+import net.minecraft.block.*;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.item.ItemStack;
+import net.minecraft.state.IProperty;
+import net.minecraft.state.properties.*;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.registry.IRegistry;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.regex.MatchResult;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public final class BlockOptionalMeta {
+
+ private final Block block;
+ private final int meta;
+ private final boolean noMeta;
+ private final Set blockstates;
+ private final ImmutableSet stateHashes;
+ private final ImmutableSet stackHashes;
+ private static final Pattern pattern = Pattern.compile("^(.+?)(?::(\\d+))?$");
+ private static final Map normalizations;
+
+ public BlockOptionalMeta(@Nonnull Block block, @Nullable Integer meta) {
+ this.block = block;
+ this.noMeta = meta == null;
+ this.meta = noMeta ? 0 : meta;
+ this.blockstates = getStates(block, meta);
+ this.stateHashes = getStateHashes(blockstates);
+ this.stackHashes = getStackHashes(blockstates);
+ }
+
+ public BlockOptionalMeta(@Nonnull Block block) {
+ this(block, null);
+ }
+
+ public BlockOptionalMeta(@Nonnull String selector) {
+ Matcher matcher = pattern.matcher(selector);
+
+ if (!matcher.find()) {
+ throw new IllegalArgumentException("invalid block selector");
+ }
+
+ MatchResult matchResult = matcher.toMatchResult();
+ noMeta = matchResult.group(2) == null;
+
+ ResourceLocation id = new ResourceLocation(matchResult.group(1));
+
+ if (!IRegistry.BLOCK.containsKey(id)) {
+ throw new IllegalArgumentException("Invalid block ID");
+ }
+
+ block = IRegistry.BLOCK.get(id);
+ meta = noMeta ? 0 : Integer.parseInt(matchResult.group(2));
+ blockstates = getStates(block, getMeta());
+ stateHashes = getStateHashes(blockstates);
+ stackHashes = getStackHashes(blockstates);
+ }
+
+ static {
+ Map _normalizations = new HashMap<>();
+ Consumer put = instance -> _normalizations.put(instance.getClass(), instance);
+ put.accept(EnumFacing.NORTH);
+ put.accept(EnumFacing.Axis.Y);
+ put.accept(Half.BOTTOM);
+ put.accept(StairsShape.STRAIGHT);
+ put.accept(AttachFace.FLOOR);
+ put.accept(DoubleBlockHalf.UPPER);
+ put.accept(SlabType.BOTTOM);
+ put.accept(DoorHingeSide.LEFT);
+ put.accept(BedPart.HEAD);
+ put.accept(RailShape.NORTH_SOUTH);
+ _normalizations.put(BlockBanner.ROTATION, 0);
+ _normalizations.put(BlockBed.OCCUPIED, false);
+ _normalizations.put(BlockBrewingStand.HAS_BOTTLE[0], false);
+ _normalizations.put(BlockBrewingStand.HAS_BOTTLE[1], false);
+ _normalizations.put(BlockBrewingStand.HAS_BOTTLE[2], false);
+ _normalizations.put(BlockButton.POWERED, false);
+ // _normalizations.put(BlockCactus.AGE, 0);
+ // _normalizations.put(BlockCauldron.LEVEL, 0);
+ // _normalizations.put(BlockChorusFlower.AGE, 0);
+ _normalizations.put(BlockChorusPlant.NORTH, false);
+ _normalizations.put(BlockChorusPlant.EAST, false);
+ _normalizations.put(BlockChorusPlant.SOUTH, false);
+ _normalizations.put(BlockChorusPlant.WEST, false);
+ _normalizations.put(BlockChorusPlant.UP, false);
+ _normalizations.put(BlockChorusPlant.DOWN, false);
+ // _normalizations.put(BlockCocoa.AGE, 0);
+ // _normalizations.put(BlockCrops.AGE, 0);
+ _normalizations.put(BlockDirtSnowy.SNOWY, false);
+ _normalizations.put(BlockDoor.OPEN, false);
+ _normalizations.put(BlockDoor.POWERED, false);
+ // _normalizations.put(BlockFarmland.MOISTURE, 0);
+ _normalizations.put(BlockFence.NORTH, false);
+ _normalizations.put(BlockFence.EAST, false);
+ _normalizations.put(BlockFence.WEST, false);
+ _normalizations.put(BlockFence.SOUTH, false);
+ // _normalizations.put(BlockFenceGate.POWERED, false);
+ // _normalizations.put(BlockFenceGate.IN_WALL, false);
+ _normalizations.put(BlockFire.AGE, 0);
+ _normalizations.put(BlockFire.NORTH, false);
+ _normalizations.put(BlockFire.EAST, false);
+ _normalizations.put(BlockFire.SOUTH, false);
+ _normalizations.put(BlockFire.WEST, false);
+ _normalizations.put(BlockFire.UP, false);
+ // _normalizations.put(BlockFrostedIce.AGE, 0);
+ _normalizations.put(BlockGrass.SNOWY, false);
+ // _normalizations.put(BlockHopper.ENABLED, true);
+ // _normalizations.put(BlockLever.POWERED, false);
+ // _normalizations.put(BlockLiquid.LEVEL, 0);
+ // _normalizations.put(BlockMycelium.SNOWY, false);
+ // _normalizations.put(BlockNetherWart.AGE, false);
+ _normalizations.put(BlockLeaves.DISTANCE, false);
+ // _normalizations.put(BlockLeaves.DECAYABLE, false);
+ // _normalizations.put(BlockObserver.POWERED, false);
+ _normalizations.put(BlockPane.NORTH, false);
+ _normalizations.put(BlockPane.EAST, false);
+ _normalizations.put(BlockPane.WEST, false);
+ _normalizations.put(BlockPane.SOUTH, false);
+ // _normalizations.put(BlockPistonBase.EXTENDED, false);
+ // _normalizations.put(BlockPressurePlate.POWERED, false);
+ // _normalizations.put(BlockPressurePlateWeighted.POWER, false);
+ // _normalizations.put(BlockRailDetector.POWERED, false);
+ // _normalizations.put(BlockRailPowered.POWERED, false);
+ _normalizations.put(BlockRedstoneWire.NORTH, false);
+ _normalizations.put(BlockRedstoneWire.EAST, false);
+ _normalizations.put(BlockRedstoneWire.SOUTH, false);
+ _normalizations.put(BlockRedstoneWire.WEST, false);
+ // _normalizations.put(BlockReed.AGE, false);
+ _normalizations.put(BlockSapling.STAGE, 0);
+ _normalizations.put(BlockStandingSign.ROTATION, 0);
+ _normalizations.put(BlockStem.AGE, 0);
+ _normalizations.put(BlockTripWire.NORTH, false);
+ _normalizations.put(BlockTripWire.EAST, false);
+ _normalizations.put(BlockTripWire.WEST, false);
+ _normalizations.put(BlockTripWire.SOUTH, false);
+ _normalizations.put(BlockVine.NORTH, false);
+ _normalizations.put(BlockVine.EAST, false);
+ _normalizations.put(BlockVine.SOUTH, false);
+ _normalizations.put(BlockVine.WEST, false);
+ _normalizations.put(BlockVine.UP, false);
+ _normalizations.put(BlockWall.UP, false);
+ _normalizations.put(BlockWall.NORTH, false);
+ _normalizations.put(BlockWall.EAST, false);
+ _normalizations.put(BlockWall.WEST, false);
+ _normalizations.put(BlockWall.SOUTH, false);
+ normalizations = Collections.unmodifiableMap(_normalizations);
+ }
+
+ private static , P extends IProperty> P castToIProperty(Object value) {
+ //noinspection unchecked
+ return (P) value;
+ }
+
+ private static , P extends IProperty> C castToIPropertyValue(P iproperty, Object value) {
+ //noinspection unchecked
+ return (C) value;
+ }
+
+ public static IBlockState normalize(IBlockState state) {
+ IBlockState newState = state;
+
+ for (IProperty property : state.getProperties()) {
+ Class valueClass = property.getValueClass();
+ if (normalizations.containsKey(property)) {
+ try {
+ newState = newState.with(
+ castToIProperty(property),
+ castToIPropertyValue(property, normalizations.get(property))
+ );
+ } catch (IllegalArgumentException ignored) {}
+ } else if (normalizations.containsKey(state.get(property))) {
+ try {
+ newState = newState.with(
+ castToIProperty(property),
+ castToIPropertyValue(property, normalizations.get(state.get(property)))
+ );
+ } catch (IllegalArgumentException ignored) {}
+ } else if (normalizations.containsKey(valueClass)) {
+ try {
+ newState = newState.with(
+ castToIProperty(property),
+ castToIPropertyValue(property, normalizations.get(valueClass))
+ );
+ } catch (IllegalArgumentException ignored) {}
+ }
+ }
+
+ return newState;
+ }
+
+ public static int stateMeta(IBlockState state) {
+ throw new UnsupportedOperationException();
+ }
+
+ private static Set getStates(@Nonnull Block block, @Nullable Integer meta) {
+ throw new UnsupportedOperationException();
+ /*return block.getBlockState().getValidStates().stream()
+ .filter(blockstate -> meta == null || stateMeta(blockstate) == meta)
+ .collect(Collectors.toSet());*/
+ }
+
+ private static ImmutableSet getStateHashes(Set blockstates) {
+ return ImmutableSet.copyOf(
+ blockstates.stream()
+ .map(IBlockState::hashCode)
+ .toArray(Integer[]::new)
+ );
+ }
+
+ private static ImmutableSet getStackHashes(Set blockstates) {
+ //noinspection ConstantConditions
+ /*return ImmutableSet.copyOf(
+ blockstates.stream()
+ .map(state -> new ItemStack(
+ state.getBlock().getItemDropped(state, ctx.world(), null, 0),
+ state.getBlock().(state)
+ ))
+ .map(stack -> ((IItemStack) (Object) stack).getBaritoneHash())
+ .toArray(Integer[]::new)
+ );*/
+ return ImmutableSet.of();
+ }
+
+ public Block getBlock() {
+ return block;
+ }
+
+ public Integer getMeta() {
+ return noMeta ? null : meta;
+ }
+
+ public boolean matches(@Nonnull Block block) {
+ return block == this.block;
+ }
+
+ public boolean matches(@Nonnull IBlockState blockstate) {
+ Block block = blockstate.getBlock();
+ return block == this.block && stateHashes.contains(blockstate.hashCode());
+ }
+
+ public boolean matches(ItemStack stack) {
+ //noinspection ConstantConditions
+ int hash = ((IItemStack) (Object) stack).getBaritoneHash();
+
+ if (noMeta) {
+ hash -= stack.getDamage();
+ }
+
+ return stackHashes.contains(hash);
+ }
+
+ @Override
+ public String toString() {
+ return String.format("BlockOptionalMeta{block=%s,meta=%s}", block, getMeta());
+ }
+
+ public IBlockState getAnyBlockState() {
+ if (blockstates.size() > 0) {
+ return blockstates.iterator().next();
+ }
+
+ return null;
+ }
+}
diff --git a/src/api/java/baritone/api/utils/BlockOptionalMetaLookup.java b/src/api/java/baritone/api/utils/BlockOptionalMetaLookup.java
new file mode 100644
index 000000000..041c6162c
--- /dev/null
+++ b/src/api/java/baritone/api/utils/BlockOptionalMetaLookup.java
@@ -0,0 +1,95 @@
+/*
+ * 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 net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.item.ItemStack;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Stream;
+
+public class BlockOptionalMetaLookup {
+
+ private final BlockOptionalMeta[] boms;
+
+ public BlockOptionalMetaLookup(BlockOptionalMeta... boms) {
+ this.boms = boms;
+ }
+
+ public BlockOptionalMetaLookup(Block... blocks) {
+ this.boms = Stream.of(blocks)
+ .map(BlockOptionalMeta::new)
+ .toArray(BlockOptionalMeta[]::new);
+ }
+
+ public BlockOptionalMetaLookup(List blocks) {
+ this.boms = blocks.stream()
+ .map(BlockOptionalMeta::new)
+ .toArray(BlockOptionalMeta[]::new);
+ }
+
+ public BlockOptionalMetaLookup(String... blocks) {
+ this.boms = Stream.of(blocks)
+ .map(BlockOptionalMeta::new)
+ .toArray(BlockOptionalMeta[]::new);
+ }
+
+ public boolean has(Block block) {
+ for (BlockOptionalMeta bom : boms) {
+ if (bom.getBlock() == block) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public boolean has(IBlockState state) {
+ for (BlockOptionalMeta bom : boms) {
+ if (bom.matches(state)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public boolean has(ItemStack stack) {
+ for (BlockOptionalMeta bom : boms) {
+ if (bom.matches(stack)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public List blocks() {
+ return Arrays.asList(boms);
+ }
+
+ @Override
+ public String toString() {
+ return String.format(
+ "BlockOptionalMetaLookup{%s}",
+ Arrays.toString(boms)
+ );
+ }
+}
diff --git a/src/api/java/baritone/api/utils/BlockUtils.java b/src/api/java/baritone/api/utils/BlockUtils.java
index f7d0d9f6b..5d2974f3e 100644
--- a/src/api/java/baritone/api/utils/BlockUtils.java
+++ b/src/api/java/baritone/api/utils/BlockUtils.java
@@ -23,9 +23,9 @@ import net.minecraft.util.registry.IRegistry;
import java.util.HashMap;
import java.util.Map;
-import java.util.Objects;
public class BlockUtils {
+
private static transient Map resourceCache = new HashMap<>();
public static String blockToString(Block block) {
@@ -40,7 +40,11 @@ public class BlockUtils {
public static Block stringToBlockRequired(String name) {
Block block = stringToBlockNullable(name);
- Objects.requireNonNull(block);
+
+ if (block == null) {
+ throw new IllegalArgumentException(String.format("Invalid block name %s", name));
+ }
+
return block;
}
diff --git a/src/api/java/baritone/api/utils/ExampleBaritoneControl.java b/src/api/java/baritone/api/utils/ExampleBaritoneControl.java
deleted file mode 100644
index 648702e53..000000000
--- a/src/api/java/baritone/api/utils/ExampleBaritoneControl.java
+++ /dev/null
@@ -1,747 +0,0 @@
-/*
- * This file is part of Baritone.
- *
- * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU 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 baritone.api.BaritoneAPI;
-import baritone.api.IBaritone;
-import baritone.api.Settings;
-import baritone.api.behavior.IPathingBehavior;
-import baritone.api.cache.IRememberedInventory;
-import baritone.api.cache.IWaypoint;
-import baritone.api.cache.Waypoint;
-import baritone.api.event.events.ChatEvent;
-import baritone.api.event.listener.AbstractGameEventListener;
-import baritone.api.pathing.goals.*;
-import baritone.api.process.IBaritoneProcess;
-import baritone.api.process.ICustomGoalProcess;
-import baritone.api.process.IGetToBlockProcess;
-import net.minecraft.block.Block;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.multiplayer.ChunkProviderClient;
-import net.minecraft.crash.CrashReport;
-import net.minecraft.entity.Entity;
-import net.minecraft.entity.item.EntityItem;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.text.ITextComponent;
-import net.minecraft.util.text.TextComponentString;
-import net.minecraft.util.text.TextFormatting;
-import net.minecraft.util.text.event.ClickEvent;
-import net.minecraft.world.chunk.Chunk;
-import net.minecraft.world.dimension.DimensionType;
-
-import java.nio.file.Path;
-import java.util.*;
-
-import static org.apache.commons.lang3.math.NumberUtils.isCreatable;
-
-public class ExampleBaritoneControl implements Helper, AbstractGameEventListener {
- private static final String COMMAND_PREFIX = "#";
-
- public final IBaritone baritone;
- public final IPlayerContext ctx;
-
- public ExampleBaritoneControl(IBaritone baritone) {
- this.baritone = baritone;
- this.ctx = baritone.getPlayerContext();
- baritone.getGameEventHandler().registerEventListener(this);
- }
-
- @Override
- public void onSendChatMessage(ChatEvent event) {
- String msg = event.getMessage();
- if (BaritoneAPI.getSettings().prefixControl.value && msg.startsWith(COMMAND_PREFIX)) {
- if (!runCommand(msg.substring(COMMAND_PREFIX.length()))) {
- logDirect("Invalid command");
- }
- event.cancel(); // always cancel if using prefixControl
- return;
- }
- if (!BaritoneAPI.getSettings().chatControl.value && !BaritoneAPI.getSettings().removePrefix.value) {
- return;
- }
- if (runCommand(msg)) {
- event.cancel();
- }
- }
-
- public boolean runCommand(String msg0) { // you may think this can be private, but impcat calls it from .b =)
- String msg = msg0.toLowerCase(Locale.US).trim(); // don't reassign the argument LOL
- IPathingBehavior pathingBehavior = baritone.getPathingBehavior();
- ICustomGoalProcess customGoalProcess = baritone.getCustomGoalProcess();
- List> toggleable = BaritoneAPI.getSettings().getAllValuesByType(Boolean.class);
- for (Settings.Setting setting : toggleable) {
- if (msg.equalsIgnoreCase(setting.getName())) {
- setting.value ^= true;
- logDirect("Toggled " + setting.getName() + " to " + setting.value);
- SettingsUtil.save(BaritoneAPI.getSettings());
- return true;
- }
- }
- if (msg.equals("baritone") || msg.equals("modifiedsettings") || msg.startsWith("settings m") || msg.equals("modified")) {
- logDirect("All settings that have been modified from their default values:");
- for (Settings.Setting setting : SettingsUtil.modifiedSettings(BaritoneAPI.getSettings())) {
- logDirect(setting.toString());
- }
- return true;
- }
- if (msg.startsWith("settings")) {
- String rest = msg.substring("settings".length());
- try {
- int page = Integer.parseInt(rest.trim());
- int min = page * 10;
- int max = Math.min(BaritoneAPI.getSettings().allSettings.size(), (page + 1) * 10);
- logDirect("Settings " + min + " to " + (max - 1) + ":");
- for (int i = min; i < max; i++) {
- logDirect(BaritoneAPI.getSettings().allSettings.get(i).toString());
- }
- } catch (Exception ex) { // NumberFormatException | ArrayIndexOutOfBoundsException and probably some others I'm forgetting lol
- ex.printStackTrace();
- logDirect("All settings:");
- for (Settings.Setting setting : BaritoneAPI.getSettings().allSettings) {
- logDirect(setting.toString());
- }
- logDirect("To get one page of ten settings at a time, do settings ");
- }
- return true;
- }
- if (msg.equals("") || msg.equals("help") || msg.equals("?")) {
- ITextComponent component = MESSAGE_PREFIX.shallowCopy();
- component.getStyle().setColor(TextFormatting.GRAY);
- TextComponentString helpLink = new TextComponentString(" Click here for instructions on how to use Baritone (https://github.com/cabaletta/baritone/blob/master/USAGE.md)");
- helpLink.getStyle().setClickEvent(new ClickEvent(ClickEvent.Action.OPEN_URL, "https://github.com/cabaletta/baritone/blob/master/USAGE.md"));
- component.appendSibling(helpLink);
- BaritoneAPI.getSettings().logger.value.accept(component);
- return true;
- }
- if (msg.contains(" ")) {
- String settingName = msg.substring(0, msg.indexOf(' '));
- String settingValue = msg.substring(msg.indexOf(' ') + 1);
- Settings.Setting setting = BaritoneAPI.getSettings().byLowerName.get(settingName);
- if (setting != null) {
- if (settingValue.equals("reset")) {
- logDirect("Resetting setting " + settingName + " to default value.");
- setting.reset();
- } else {
- try {
- SettingsUtil.parseAndApply(BaritoneAPI.getSettings(), settingName, settingValue);
- } catch (Exception ex) {
- logDirect("Unable to parse setting");
- return true;
- }
- }
- SettingsUtil.save(BaritoneAPI.getSettings());
- logDirect(setting.toString());
- return true;
- }
- }
- if (BaritoneAPI.getSettings().byLowerName.containsKey(msg)) {
- Settings.Setting setting = BaritoneAPI.getSettings().byLowerName.get(msg);
- logDirect(setting.toString());
- return true;
- }
-
- if (msg.startsWith("goal")) {
- String rest = msg.substring(4).trim();
- Goal goal;
- if (rest.equals("clear") || rest.equals("none")) {
- goal = null;
- } else {
- String[] params = rest.split(" ");
- if (params[0].equals("")) {
- params = new String[]{};
- }
- goal = parseGoal(params);
- if (goal == null) {
- return true;
- }
- }
- customGoalProcess.setGoal(goal);
- logDirect("Goal: " + goal);
- return true;
- }
- if (msg.equals("crash")) {
- StringBuilder meme = new StringBuilder();
- CrashReport rep = new CrashReport("Manually triggered debug crash", new Throwable());
- mc.addGraphicsAndWorldToCrashReport(rep);
- rep.getSectionsInStringBuilder(meme);
- System.out.println(meme);
- logDirect(meme.toString());
- logDirect("ok");
- return true;
- }
- if (msg.equals("path")) {
- if (pathingBehavior.getGoal() == null) {
- logDirect("No goal.");
- } else if (pathingBehavior.getGoal().isInGoal(ctx.playerFeet())) {
- logDirect("Already in goal");
- } else if (pathingBehavior.isPathing()) {
- logDirect("Currently executing a path. Please cancel it first.");
- } else {
- customGoalProcess.setGoalAndPath(pathingBehavior.getGoal());
- }
- return true;
- }
- /*if (msg.equals("fullpath")) {
- if (pathingBehavior.getGoal() == null) {
- logDirect("No goal.");
- } else {
- logDirect("Started segmented calculator");
- SegmentedCalculator.calculateSegmentsThreaded(pathingBehavior.pathStart(), pathingBehavior.getGoal(), new CalculationContext(baritone, true), ipath -> {
- logDirect("Found a path");
- logDirect("Ends at " + ipath.getDest());
- logDirect("Length " + ipath.length());
- logDirect("Estimated time " + ipath.ticksRemainingFrom(0));
- pathingBehavior.secretCursedFunctionDoNotCall(ipath); // it's okay when *I* do it
- }, () -> {
- logDirect("Path calculation failed, no path");
- });
- }
- return true;
- }*/
- if (msg.equals("proc")) {
- Optional proc = baritone.getPathingControlManager().mostRecentInControl();
- if (!proc.isPresent()) {
- logDirect("No process is in control");
- return true;
- }
- IBaritoneProcess p = proc.get();
- logDirect("Class: " + p.getClass());
- logDirect("Priority: " + p.priority());
- logDirect("Temporary: " + p.isTemporary());
- logDirect("Display name: " + p.displayName());
- logDirect("Command: " + baritone.getPathingControlManager().mostRecentCommand());
- return true;
- }
- if (msg.equals("version")) {
- String version = ExampleBaritoneControl.class.getPackage().getImplementationVersion();
- if (version == null) {
- logDirect("No version detected. Either dev environment or broken install.");
- } else {
- logDirect("You are using Baritone v" + version);
- }
- return true;
- }
- if (msg.equals("repack") || msg.equals("rescan")) {
- logDirect("Queued " + repack() + " chunks for repacking");
- return true;
- }
- if (msg.startsWith("build")) {
- String file;
- BlockPos origin;
- try {
- String[] coords = msg.substring("build".length()).trim().split(" ");
- file = coords[0] + ".schematic";
- origin = new BlockPos(parseOrDefault(coords[1], ctx.playerFeet().x, 1), parseOrDefault(coords[2], ctx.playerFeet().y, 1), parseOrDefault(coords[3], ctx.playerFeet().z, 1));
- } catch (Exception ex) {
- file = msg.substring(5).trim() + ".schematic";
- origin = ctx.playerFeet();
- }
- logDirect("Loading '" + file + "' to build from origin " + origin);
- boolean success = baritone.getBuilderProcess().build(file, origin);
- logDirect(success ? "Loaded" : "Unable to load");
- return true;
- }
- if (msg.startsWith("schematica")) {
- baritone.getBuilderProcess().buildOpenSchematic();
- return true;
- }
- if (msg.equals("come")) {
- customGoalProcess.setGoalAndPath(new GoalBlock(new BlockPos(Helper.mc.getRenderViewEntity())));
- logDirect("Coming");
- return true;
- }
- if (msg.equals("axis") || msg.equals("highway")) {
- customGoalProcess.setGoalAndPath(new GoalAxis());
- return true;
- }
- if (msg.equals("cancel") || msg.equals("stop")) {
- pathingBehavior.cancelEverything();
- logDirect("ok canceled");
- return true;
- }
- if (msg.equals("forcecancel")) {
- pathingBehavior.cancelEverything();
- pathingBehavior.forceCancel();
- logDirect("ok force canceled");
- return true;
- }
- if (msg.equals("gc")) {
- System.gc();
- logDirect("Called System.gc();");
- return true;
- }
- if (msg.equals("invert")) {
- Goal goal = pathingBehavior.getGoal();
- BlockPos runAwayFrom;
- if (goal instanceof GoalXZ) {
- runAwayFrom = new BlockPos(((GoalXZ) goal).getX(), 0, ((GoalXZ) goal).getZ());
- } else if (goal instanceof GoalBlock) {
- runAwayFrom = ((GoalBlock) goal).getGoalPos();
- } else {
- logDirect("Goal must be GoalXZ or GoalBlock to invert");
- logDirect("Inverting goal of player feet");
- runAwayFrom = ctx.playerFeet();
- }
- customGoalProcess.setGoalAndPath(new GoalRunAway(1, runAwayFrom) {
- @Override
- public boolean isInGoal(int x, int y, int z) {
- return false;
- }
- });
- return true;
- }
- if (msg.startsWith("cleararea")) {
- String suffix = msg.substring("cleararea".length());
- BlockPos corner1;
- BlockPos corner2;
- if (suffix.isEmpty()) {
- // clear the area from the current goal to here
- Goal goal = baritone.getPathingBehavior().getGoal();
- if (!(goal instanceof GoalBlock)) {
- logDirect("Need to specify goal of opposite corner");
- return true;
- }
- corner1 = ((GoalBlock) goal).getGoalPos();
- corner2 = ctx.playerFeet();
- } else {
- try {
- String[] spl = suffix.split(" ");
- corner1 = ctx.playerFeet();
- corner2 = new BlockPos(Integer.parseInt(spl[0]), Integer.parseInt(spl[1]), Integer.parseInt(spl[2]));
- } catch (NumberFormatException | ArrayIndexOutOfBoundsException | NullPointerException ex) {
- logDirect("unable to parse");
- return true;
- }
- }
- baritone.getBuilderProcess().clearArea(corner1, corner2);
- return true;
- }
- if (msg.equals("resume")) {
- baritone.getBuilderProcess().resume();
- logDirect("resumed");
- return true;
- }
- if (msg.equals("pause")) {
- baritone.getBuilderProcess().pause();
- logDirect("paused");
- return true;
- }
- if (msg.equals("reset")) {
- for (Settings.Setting setting : BaritoneAPI.getSettings().allSettings) {
- setting.reset();
- }
- SettingsUtil.save(BaritoneAPI.getSettings());
- logDirect("Baritone settings reset");
- return true;
- }
- if (msg.equals("tunnel")) {
- customGoalProcess.setGoalAndPath(new GoalStrictDirection(ctx.playerFeet(), ctx.player().getHorizontalFacing()));
- logDirect("tunneling");
- return true;
- }
- if (msg.equals("render")) {
- BetterBlockPos pf = ctx.playerFeet();
- int dist = (Minecraft.getInstance().gameSettings.renderDistanceChunks + 1) * 16;
- Minecraft.getInstance().worldRenderer.markBlockRangeForRenderUpdate(pf.x - dist, pf.y - 256, pf.z - dist, pf.x + dist, pf.y + 256, pf.z + dist);
- logDirect("okay");
- return true;
- }
- if (msg.equals("farm")) {
- baritone.getFarmProcess().farm();
- logDirect("farming");
- return true;
- }
- if (msg.equals("chests")) {
- for (Map.Entry entry : baritone.getWorldProvider().getCurrentWorld().getContainerMemory().getRememberedInventories().entrySet()) {
- logDirect(entry.getKey() + "");
- log(entry.getValue().getContents());
- }
- return true;
- }
- if (msg.startsWith("followentities")) {
- baritone.getFollowProcess().follow(Entity.class::isInstance);
- logDirect("Following any entities");
- return true;
- }
- if (msg.startsWith("followplayers")) {
- baritone.getFollowProcess().follow(EntityPlayer.class::isInstance); // O P P A
- logDirect("Following any players");
- return true;
- }
- if (msg.startsWith("followentity")) {
- String name = msg.substring(12).trim();
- Optional toFollow = Optional.empty();
- for (Entity entity : ctx.world().loadedEntityList) {
- String entityName = entity.getName().getFormattedText().trim().toLowerCase();
- if ((entityName.contains(name) || name.contains(entityName)) && !(entity instanceof EntityItem || entity instanceof EntityPlayer)) { // We dont want it following players while `#follow` exists.
- toFollow = Optional.of(entity);
- }
- }
- if (!toFollow.isPresent()) {
- logDirect("Entity not found");
- return true;
- }
- Entity effectivelyFinal = toFollow.get();
- baritone.getFollowProcess().follow(effectivelyFinal::equals);
- logDirect("Following entity " + toFollow.get());
- return true;
- }
- if (msg.startsWith("follow")) {
- String name = msg.substring(6).trim();
- Optional toFollow = Optional.empty();
- if (name.length() == 0) {
- toFollow = ctx.getSelectedEntity();
- } else {
- for (EntityPlayer pl : ctx.world().playerEntities) {
- String theirName = pl.getName().getString().trim().toLowerCase();
- if (!theirName.equals(ctx.player().getName().getString().trim().toLowerCase()) && (theirName.contains(name) || name.contains(theirName))) { // don't follow ourselves lol
- toFollow = Optional.of(pl);
- }
- }
- }
- if (!toFollow.isPresent()) {
- logDirect("Not found");
- return true;
- }
- Entity effectivelyFinal = toFollow.get();
- baritone.getFollowProcess().follow(effectivelyFinal::equals);
- logDirect("Following " + toFollow.get());
- return true;
- }
- if (msg.startsWith("explorefilter")) {
- // explorefilter blah.json
- // means that entries in blah.json are already explored
- // explorefilter blah.json invert
- // means that entries in blah.json are NOT already explored
- String path = msg.substring("explorefilter".length()).trim();
- String[] parts = path.split(" ");
- Path path1 = Minecraft.getInstance().gameDir.toPath().resolve(parts[0]);
- boolean invert = parts.length > 1;
- try {
- baritone.getExploreProcess().applyJsonFilter(path1, invert);
- logDirect("Loaded filter. Inverted: " + invert);
- if (invert) {
- logDirect("Chunks on this list will be treated as possibly unexplored, all others will be treated as certainly explored");
- } else {
- logDirect("Chunks on this list will be treated as certainly explored, all others will be treated as possibly unexplored");
- }
- } catch (Exception e) {
- e.printStackTrace();
- logDirect("Unable to load " + path1);
- }
- return true;
- }
- if (msg.equals("reloadall")) {
- baritone.getWorldProvider().getCurrentWorld().getCachedWorld().reloadAllFromDisk();
- logDirect("ok");
- return true;
- }
- if (msg.equals("saveall")) {
- baritone.getWorldProvider().getCurrentWorld().getCachedWorld().save();
- logDirect("ok");
- return true;
- }
- if (msg.startsWith("explore")) {
- String rest = msg.substring("explore".length()).trim();
- int centerX;
- int centerZ;
- try {
- centerX = Integer.parseInt(rest.split(" ")[0]);
- centerZ = Integer.parseInt(rest.split(" ")[1]);
- } catch (Exception ex) {
- centerX = ctx.playerFeet().x;
- centerZ = ctx.playerFeet().z;
- }
- baritone.getExploreProcess().explore(centerX, centerZ);
- logDirect("Exploring from " + centerX + "," + centerZ);
- return true;
- }
- if (msg.equals("blacklist")) {
- IGetToBlockProcess proc = baritone.getGetToBlockProcess();
- if (!proc.isActive()) {
- logDirect("GetToBlockProcess is not currently active");
- return true;
- }
- if (proc.blacklistClosest()) {
- logDirect("Blacklisted closest instances");
- } else {
- logDirect("No known locations, unable to blacklist");
- }
- return true;
- }
- if (msg.startsWith("find")) {
- repack();
- String blockType = msg.substring(4).trim();
- ArrayList locs = baritone.getWorldProvider().getCurrentWorld().getCachedWorld().getLocationsOf(blockType, 1, ctx.playerFeet().getX(), ctx.playerFeet().getZ(), 4);
- logDirect("Have " + locs.size() + " locations");
- for (BlockPos pos : locs) {
- Block actually = ctx.world().getBlockState(pos).getBlock();
- if (!BlockUtils.blockToString(actually).equalsIgnoreCase(blockType)) {
- logDebug("Was looking for " + blockType + " but actually found " + actually + " " + BlockUtils.blockToString(actually));
- }
- }
- return true;
- }
- if (msg.startsWith("mine")) {
- repack();
- String[] blockTypes = msg.substring(4).trim().split(" ");
- try {
- int quantity = Integer.parseInt(blockTypes[1]);
- Block block = BlockUtils.stringToBlockRequired(blockTypes[0]);
- baritone.getMineProcess().mine(quantity, block);
- logDirect("Will mine " + quantity + " " + blockTypes[0]);
- return true;
- } catch (NumberFormatException | ArrayIndexOutOfBoundsException | NullPointerException ex) {}
- for (String s : blockTypes) {
- if (BlockUtils.stringToBlockNullable(s) == null) {
- logDirect(s + " isn't a valid block name");
- return true;
- }
-
- }
- baritone.getMineProcess().mineByName(0, blockTypes);
- logDirect("Started mining blocks of type " + Arrays.toString(blockTypes));
- return true;
- }
- if (msg.equals("click")) {
- baritone.openClick();
- logDirect("aight dude");
- return true;
- }
- if (msg.startsWith("thisway") || msg.startsWith("forward")) {
- try {
- Goal goal = GoalXZ.fromDirection(ctx.playerFeetAsVec(), ctx.player().rotationYaw, Double.parseDouble(msg.substring(7).trim()));
- customGoalProcess.setGoal(goal);
- logDirect("Goal: " + goal);
- } catch (NumberFormatException ex) {
- logDirect("Error unable to parse '" + msg.substring(7).trim() + "' to a double.");
- }
- return true;
- }
- if (msg.startsWith("list") || msg.startsWith("get ") || msg.startsWith("show")) {
- String waypointType = msg.substring(4).trim();
- if (waypointType.endsWith("s")) {
- // for example, "show deaths"
- waypointType = waypointType.substring(0, waypointType.length() - 1);
- }
- IWaypoint.Tag tag = IWaypoint.Tag.fromString(waypointType);
- if (tag == null) {
- logDirect("Not a valid tag. Tags are: " + Arrays.asList(IWaypoint.Tag.values()).toString().toLowerCase());
- return true;
- }
- Set waypoints = baritone.getWorldProvider().getCurrentWorld().getWaypoints().getByTag(tag);
- // might as well show them from oldest to newest
- List sorted = new ArrayList<>(waypoints);
- sorted.sort(Comparator.comparingLong(IWaypoint::getCreationTimestamp));
- logDirect("Waypoints under tag " + tag + ":");
- for (IWaypoint waypoint : sorted) {
- logDirect(waypoint.toString());
- }
- return true;
- }
- if (msg.startsWith("save")) {
- String name = msg.substring(4).trim();
- BlockPos pos = ctx.playerFeet();
- if (name.contains(" ")) {
- logDirect("Name contains a space, assuming it's in the format 'save waypointName X Y Z'");
- String[] parts = name.split(" ");
- if (parts.length != 4) {
- logDirect("Unable to parse, expected four things");
- return true;
- }
- try {
- pos = new BlockPos(Integer.parseInt(parts[1]), Integer.parseInt(parts[2]), Integer.parseInt(parts[3]));
- } catch (NumberFormatException ex) {
- logDirect("Unable to parse coordinate integers");
- return true;
- }
- name = parts[0];
- }
- baritone.getWorldProvider().getCurrentWorld().getWaypoints().addWaypoint(new Waypoint(name, IWaypoint.Tag.USER, pos));
- logDirect("Saved user defined position " + pos + " under name '" + name + "'. Say 'goto " + name + "' to set goal, say 'list user' to list custom waypoints.");
- return true;
- }
- if (msg.startsWith("delete")) {
- String name = msg.substring(6).trim();
- IWaypoint waypoint = baritone.getWorldProvider().getCurrentWorld().getWaypoints().getAllWaypoints().stream().filter(w -> w.getTag() == IWaypoint.Tag.USER && w.getName().equalsIgnoreCase(name)).findFirst().orElse(null);
- if (waypoint == null) {
- logDirect("No user defined position under the name '" + name + "' found.");
- return true;
- }
- baritone.getWorldProvider().getCurrentWorld().getWaypoints().removeWaypoint(waypoint);
- logDirect("Deleted user defined position under name '" + name + "'.");
- return true;
- }
- if (msg.startsWith("goto")) {
- repack();
- String waypointType = msg.substring(4).trim();
- if (waypointType.endsWith("s") && IWaypoint.Tag.fromString(waypointType.substring(0, waypointType.length() - 1)) != null) {
- // for example, "show deaths"
- waypointType = waypointType.substring(0, waypointType.length() - 1);
- }
- IWaypoint.Tag tag = IWaypoint.Tag.fromString(waypointType);
- IWaypoint waypoint;
- if (tag == null) {
- String mining = waypointType;
- Block block = BlockUtils.stringToBlockNullable(mining);
- //logDirect("Not a valid tag. Tags are: " + Arrays.asList(Waypoint.Tag.values()).toString().toLowerCase());
- if (block == null) {
- waypoint = baritone.getWorldProvider().getCurrentWorld().getWaypoints().getAllWaypoints().stream().filter(w -> w.getName().equalsIgnoreCase(mining)).max(Comparator.comparingLong(IWaypoint::getCreationTimestamp)).orElse(null);
- if (waypoint == null) {
- Goal goal = parseGoal(waypointType.split(" "));
- if (goal != null) {
- logDirect("Going to " + goal);
- customGoalProcess.setGoalAndPath(goal);
- }
- return true;
- }
- } else {
- baritone.getGetToBlockProcess().getToBlock(block);
- return true;
- }
- } else {
- waypoint = baritone.getWorldProvider().getCurrentWorld().getWaypoints().getMostRecentByTag(tag);
- if (waypoint == null) {
- logDirect("None saved for tag " + tag);
- return true;
- }
- }
- Goal goal = waypoint.getTag() == IWaypoint.Tag.BED ? new GoalGetToBlock(waypoint.getLocation()) : new GoalBlock(waypoint.getLocation());
- customGoalProcess.setGoalAndPath(goal);
- return true;
- }
- if (msg.equals("spawn") || msg.equals("bed")) {
- IWaypoint waypoint = baritone.getWorldProvider().getCurrentWorld().getWaypoints().getMostRecentByTag(IWaypoint.Tag.BED);
- if (waypoint == null) {
- BlockPos spawnPoint = ctx.player().getBedLocation();
- // for some reason the default spawnpoint is underground sometimes
- Goal goal = new GoalXZ(spawnPoint.getX(), spawnPoint.getZ());
- logDirect("spawn not saved, defaulting to world spawn. set goal to " + goal);
- customGoalProcess.setGoalAndPath(goal);
- } else {
- Goal goal = new GoalGetToBlock(waypoint.getLocation());
- customGoalProcess.setGoalAndPath(goal);
- logDirect("Set goal to most recent bed " + goal);
- }
- return true;
- }
- if (msg.equals("sethome")) {
- baritone.getWorldProvider().getCurrentWorld().getWaypoints().addWaypoint(new Waypoint("", IWaypoint.Tag.HOME, ctx.playerFeet()));
- logDirect("Saved. Say home to set goal.");
- return true;
- }
- if (msg.equals("home")) {
- IWaypoint waypoint = baritone.getWorldProvider().getCurrentWorld().getWaypoints().getMostRecentByTag(IWaypoint.Tag.HOME);
- if (waypoint == null) {
- logDirect("home not saved");
- } else {
- Goal goal = new GoalBlock(waypoint.getLocation());
- customGoalProcess.setGoalAndPath(goal);
- logDirect("Going to saved home " + goal);
- }
- return true;
- }
- if (msg.equals("damn")) {
- logDirect("daniel");
- }
- return false;
- }
-
- private int repack() {
- ChunkProviderClient cli = (ChunkProviderClient) ctx.world().getChunkProvider();
- int playerChunkX = ctx.playerFeet().getX() >> 4;
- int playerChunkZ = ctx.playerFeet().getZ() >> 4;
- int count = 0;
- for (int x = playerChunkX - 40; x <= playerChunkX + 40; x++) {
- for (int z = playerChunkZ - 40; z <= playerChunkZ + 40; z++) {
- Chunk chunk = cli.getChunk(x, z, false, false);
- if (chunk != null) {
- count++;
- baritone.getWorldProvider().getCurrentWorld().getCachedWorld().queueForPacking(chunk);
- }
- }
- }
- return count;
- }
-
- private int parseOrDefault(String str, int i, double dimensionFactor) {
- return str.equals("~") ? i : str.startsWith("~") ? (int) (Integer.parseInt(str.substring(1)) * dimensionFactor) + i : (int) (Integer.parseInt(str) * dimensionFactor);
- }
-
- private void log(List stacks) {
- for (ItemStack stack : stacks) {
- if (!stack.isEmpty()) {
- logDirect(stack.getCount() + "x " + stack.getDisplayName() + "@" + stack.getDamage());
- }
- }
- }
-
- private Goal parseGoal(String[] params) {
- Goal goal;
- try {
- BetterBlockPos playerFeet = ctx.playerFeet();
-
- int length = params.length - 1; // length has to be smaller when a dimension parameter is added
- if (params.length < 1 || (isCreatable(params[params.length - 1]) || params[params.length - 1].startsWith("~"))) {
- length = params.length;
- }
- switch (length) {
- case 0:
- goal = new GoalBlock(playerFeet);
- break;
- case 1:
- goal = new GoalYLevel(parseOrDefault(params[0], playerFeet.y, 1));
- break;
- case 2:
- goal = new GoalXZ(parseOrDefault(params[0], playerFeet.x, calculateDimensionFactor(params[params.length - 1])), parseOrDefault(params[1], playerFeet.z, calculateDimensionFactor(params[params.length - 1])));
- break;
- case 3:
- goal = new GoalBlock(new BlockPos(parseOrDefault(params[0], playerFeet.x, calculateDimensionFactor(params[params.length - 1])), parseOrDefault(params[1], playerFeet.y, 1), parseOrDefault(params[2], playerFeet.z, calculateDimensionFactor(params[params.length - 1]))));
- break;
- default:
- logDirect("unable to understand lol");
- return null;
- }
- } catch (NumberFormatException ex) {
- logDirect("unable to parse integer " + ex);
- return null;
- }
- return goal;
- }
-
-
- private double calculateDimensionFactor(String to) {
- return Math.pow(8, ctx.world().dimension.getType().getId() - getDimensionByName(to.toLowerCase()).getId());
- }
-
- private DimensionType getDimensionByName(String name) {
- if ("the_end".contains(name)) {
- return DimensionType.THE_END;
- }
- if ("the_overworld".contains(name) || "surface".contains(name)) {
- return DimensionType.OVERWORLD;
- }
- if ("the_nether".contains(name) || "hell".contains(name)) {
- return DimensionType.NETHER;
- }
- return ctx.world().dimension.getType();
- }
-
-}
diff --git a/src/api/java/baritone/api/utils/Helper.java b/src/api/java/baritone/api/utils/Helper.java
index f05f5ed08..7feb2ba50 100755
--- a/src/api/java/baritone/api/utils/Helper.java
+++ b/src/api/java/baritone/api/utils/Helper.java
@@ -23,6 +23,9 @@ import net.minecraft.util.text.ITextComponent;
import net.minecraft.util.text.TextComponentString;
import net.minecraft.util.text.TextFormatting;
+import java.util.Arrays;
+import java.util.stream.Stream;
+
/**
* @author Brady
* @since 8/1/2018
@@ -34,16 +37,26 @@ public interface Helper {
*/
Helper HELPER = new Helper() {};
- ITextComponent MESSAGE_PREFIX = new TextComponentString(String.format(
- "%s[%sBaritone%s]%s",
- TextFormatting.DARK_PURPLE,
- TextFormatting.LIGHT_PURPLE,
- TextFormatting.DARK_PURPLE,
- TextFormatting.GRAY
- ));
-
+ /**
+ * Instance of the game
+ */
Minecraft mc = Minecraft.getInstance();
+ static ITextComponent getPrefix() {
+ // Inner text component
+ ITextComponent baritone = new TextComponentString(BaritoneAPI.getSettings().shortBaritonePrefix.value ? "B" : "Baritone");
+ baritone.getStyle().setColor(TextFormatting.LIGHT_PURPLE);
+
+ // Outer brackets
+ ITextComponent prefix = new TextComponentString("");
+ prefix.getStyle().setColor(TextFormatting.DARK_PURPLE);
+ prefix.appendText("[");
+ prefix.appendSibling(baritone);
+ prefix.appendText("]");
+
+ return prefix;
+ }
+
/**
* Send a message to chat only if chatDebug is on
*
@@ -59,14 +72,40 @@ public interface Helper {
}
/**
- * Send a message to chat regardless of chatDebug (should only be used for critically important messages, or as a direct response to a chat command)
+ * Send components to chat with the [Baritone] prefix
+ *
+ * @param components The components to send
+ */
+ default void logDirect(ITextComponent... components) {
+ ITextComponent component = new TextComponentString("");
+ component.appendSibling(getPrefix());
+ component.appendSibling(new TextComponentString(" "));
+ Arrays.asList(components).forEach(component::appendSibling);
+ mc.addScheduledTask(() -> BaritoneAPI.getSettings().logger.value.accept(component));
+ }
+
+ /**
+ * Send a message to chat regardless of chatDebug (should only be used for critically important messages, or as a
+ * direct response to a chat command)
+ *
+ * @param message The message to display in chat
+ * @param color The color to print that message in
+ */
+ default void logDirect(String message, TextFormatting color) {
+ Stream.of(message.split("\n")).forEach(line -> {
+ ITextComponent component = new TextComponentString(line.replace("\t", " "));
+ component.getStyle().setColor(color);
+ logDirect(component);
+ });
+ }
+
+ /**
+ * Send a message to chat regardless of chatDebug (should only be used for critically important messages, or as a
+ * direct response to a chat command)
*
* @param message The message to display in chat
*/
default void logDirect(String message) {
- ITextComponent component = MESSAGE_PREFIX.shallowCopy();
- component.getStyle().setColor(TextFormatting.GRAY);
- component.appendSibling(new TextComponentString(" " + message));
- Minecraft.getInstance().addScheduledTask(() -> BaritoneAPI.getSettings().logger.value.accept(component));
+ logDirect(message, TextFormatting.GRAY);
}
}
diff --git a/src/api/java/baritone/api/utils/IPlayerContext.java b/src/api/java/baritone/api/utils/IPlayerContext.java
index f0a5c3314..7918d1fbe 100644
--- a/src/api/java/baritone/api/utils/IPlayerContext.java
+++ b/src/api/java/baritone/api/utils/IPlayerContext.java
@@ -47,9 +47,21 @@ public interface IPlayerContext {
default BetterBlockPos playerFeet() {
// TODO find a better way to deal with soul sand!!!!!
BetterBlockPos feet = new BetterBlockPos(player().posX, player().posY + 0.1251, player().posZ);
- if (world().getBlockState(feet).getBlock() instanceof BlockSlab) {
- return feet.up();
- }
+
+ // sometimes when calling this from another thread or while world is null, it'll throw a NullPointerException
+ // that causes the game to immediately crash
+ //
+ // so of course crashing on 2b is horribly bad due to queue times and logout spot
+ // catch the NPE and ignore it if it does happen
+ //
+ // this does not impact performance at all since we're not null checking constantly
+ // if there is an exception, the only overhead is Java generating the exception object... so we can ignore it
+ try {
+ if (world().getBlockState(feet).getBlock() instanceof BlockSlab) {
+ return feet.up();
+ }
+ } catch (NullPointerException ignored) {}
+
return feet;
}
diff --git a/src/api/java/baritone/api/utils/IPlayerController.java b/src/api/java/baritone/api/utils/IPlayerController.java
index 14334d5e2..05199fcac 100644
--- a/src/api/java/baritone/api/utils/IPlayerController.java
+++ b/src/api/java/baritone/api/utils/IPlayerController.java
@@ -35,21 +35,27 @@ import net.minecraft.world.World;
*/
public interface IPlayerController {
+ void syncHeldItem();
+
+ boolean hasBrokenBlock();
+
boolean onPlayerDamageBlock(BlockPos pos, EnumFacing side);
void resetBlockRemoving();
ItemStack windowClick(int windowId, int slotId, int mouseButton, ClickType type, EntityPlayer player);
- void setGameType(GameType type);
-
GameType getGameType();
- default double getBlockReachDistance() {
- return this.getGameType().isCreative() ? 5.0F : 4.5F;
- }
-
EnumActionResult processRightClickBlock(EntityPlayerSP player, World world, BlockPos pos, EnumFacing direction, Vec3d vec, EnumHand hand);
EnumActionResult processRightClick(EntityPlayerSP player, World world, EnumHand hand);
+
+ boolean clickBlock(BlockPos loc, EnumFacing face);
+
+ void setHittingBlock(boolean hittingBlock);
+
+ default double getBlockReachDistance() {
+ return this.getGameType().isCreative() ? 5.0F : 4.5F;
+ }
}
diff --git a/src/api/java/baritone/api/utils/ISchematic.java b/src/api/java/baritone/api/utils/ISchematic.java
index 821dc68c3..2adcbdd58 100644
--- a/src/api/java/baritone/api/utils/ISchematic.java
+++ b/src/api/java/baritone/api/utils/ISchematic.java
@@ -20,9 +20,11 @@ package baritone.api.utils;
import net.minecraft.block.state.IBlockState;
import net.minecraft.util.EnumFacing;
+import java.util.List;
+
/**
- * Basic representation of a schematic. Provides the dimensions and
- * the desired statefor a given position relative to the origin.
+ * Basic representation of a schematic. Provides the dimensions and the desired state for a given position relative to
+ * the origin.
*
* @author leijurv
*/
@@ -36,12 +38,13 @@ public interface ISchematic {
* However, in the case of something like a map art, anything that's below the level of the map art doesn't matter,
* so this function should return false in that case. (i.e. it doesn't really have to be air below the art blocks)
*
- * @param x The x position of the block, relative to the origin
- * @param y The y position of the block, relative to the origin
- * @param z The z position of the block, relative to the origin
+ * @param x The x position of the block, relative to the origin
+ * @param y The y position of the block, relative to the origin
+ * @param z The z position of the block, relative to the origin
+ * @param currentState The current state of that block in the world, or null
* @return Whether or not the specified position is within the bounds of this schematic
*/
- default boolean inSchematic(int x, int y, int z) {
+ default boolean inSchematic(int x, int y, int z, IBlockState currentState) {
return x >= 0 && x < widthX() && y >= 0 && y < heightY() && z >= 0 && z < lengthZ();
}
@@ -61,12 +64,14 @@ public interface ISchematic {
/**
* Returns the desired block state at a given (X, Y, Z) position relative to the origin (0, 0, 0).
*
- * @param x The x position of the block, relative to the origin
- * @param y The y position of the block, relative to the origin
- * @param z The z position of the block, relative to the origin
+ * @param x The x position of the block, relative to the origin
+ * @param y The y position of the block, relative to the origin
+ * @param z The z position of the block, relative to the origin
+ * @param current The current state of that block in the world, or null
+ * @param approxPlaceable The list of blockstates estimated to be placeable
* @return The desired block state at the specified position
*/
- IBlockState desiredState(int x, int y, int z);
+ IBlockState desiredState(int x, int y, int z, IBlockState current, List approxPlaceable);
/**
* @return The width (X axis length) of this schematic
@@ -82,4 +87,4 @@ public interface ISchematic {
* @return The length (Z axis length) of this schematic
*/
int lengthZ();
-}
\ No newline at end of file
+}
diff --git a/src/api/java/baritone/api/utils/MyChunkPos.java b/src/api/java/baritone/api/utils/MyChunkPos.java
index 8b61012f9..7cda5aa35 100644
--- a/src/api/java/baritone/api/utils/MyChunkPos.java
+++ b/src/api/java/baritone/api/utils/MyChunkPos.java
@@ -34,4 +34,4 @@ public class MyChunkPos {
public String toString() {
return x + ", " + z;
}
-}
\ No newline at end of file
+}
diff --git a/src/api/java/baritone/api/utils/SettingsUtil.java b/src/api/java/baritone/api/utils/SettingsUtil.java
index b540342f1..ce281665f 100644
--- a/src/api/java/baritone/api/utils/SettingsUtil.java
+++ b/src/api/java/baritone/api/utils/SettingsUtil.java
@@ -17,14 +17,15 @@
package baritone.api.utils;
+import baritone.api.BaritoneAPI;
import baritone.api.Settings;
import net.minecraft.block.Block;
import net.minecraft.client.Minecraft;
import net.minecraft.item.Item;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.ResourceLocation;
-import net.minecraft.util.registry.IRegistry;
import net.minecraft.util.math.Vec3i;
+import net.minecraft.util.registry.IRegistry;
import java.awt.*;
import java.io.BufferedReader;
@@ -36,7 +37,6 @@ import java.nio.file.Files;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;
import java.util.ArrayList;
-import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.function.Consumer;
@@ -44,9 +44,11 @@ import java.util.function.Function;
import java.util.regex.Matcher;
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().gameDir.toPath().resolve("baritone").resolve("settings.txt");
private static final Pattern SETTING_PATTERN = Pattern.compile("^(?[^ ]+) +(?.+)"); // key and value split by the first space
@@ -122,15 +124,54 @@ public class SettingsUtil {
return modified;
}
+ /**
+ * Gets the type of a setting and returns it as a string, with package names stripped.
+ *
+ * For example, if the setting type is {@code java.util.List}, this function returns
+ * {@code List}.
+ *
+ * @param setting The setting
+ * @return The type
+ */
+ public static String settingTypeToString(Settings.Setting setting) {
+ return setting.getType().getTypeName()
+ .replaceAll("(?:\\w+\\.)+(\\w+)", "$1");
+ }
+
+ public static String settingValueToString(Settings.Setting setting, T value) throws IllegalArgumentException {
+ Parser io = Parser.getParser(setting.getType());
+
+ if (io == null) {
+ throw new IllegalStateException("Missing " + setting.getValueClass() + " " + setting.getName());
+ }
+
+ return io.toString(new ParserContext(setting), value);
+ }
+
+ public static String settingValueToString(Settings.Setting setting) throws IllegalArgumentException {
+ //noinspection unchecked
+ return settingValueToString(setting, setting.value);
+ }
+
+ public static String settingDefaultToString(Settings.Setting setting) throws IllegalArgumentException {
+ //noinspection unchecked
+ return settingValueToString(setting, setting.defaultValue);
+ }
+
+ public static String maybeCensor(int coord) {
+ if (BaritoneAPI.getSettings().censorCoordinates.value) {
+ return "";
+ }
+
+ return Integer.toString(coord);
+ }
+
public static String settingToString(Settings.Setting setting) throws IllegalStateException {
if (setting.getName().equals("logger")) {
return "logger";
}
- Parser io = Parser.getParser(setting.getType());
- if (io == null) {
- throw new IllegalStateException("Missing " + setting.getValueClass() + " " + setting.getName());
- }
- return setting.getName() + " " + io.toString(new ParserContext(setting), setting.value);
+
+ return setting.getName() + " " + settingValueToString(setting);
}
public static void parseAndApply(Settings settings, String settingName, String settingValue) throws IllegalStateException, NumberFormatException {
@@ -176,6 +217,7 @@ public class SettingsUtil {
INTEGER(Integer.class, Integer::parseInt),
FLOAT(Float.class, Float::parseFloat),
LONG(Long.class, Long::parseLong),
+ STRING(String.class, String::new),
ENUMFACING(EnumFacing.class, EnumFacing::byName),
COLOR(
Color.class,
@@ -202,7 +244,7 @@ public class SettingsUtil {
public Object parse(ParserContext context, String raw) {
Type type = ((ParameterizedType) context.getSetting().getType()).getActualTypeArguments()[0];
Parser parser = Parser.getParser(type);
- return Arrays.stream(raw.split(","))
+ return Stream.of(raw.split(","))
.map(s -> parser.parse(context, s))
.collect(Collectors.toList());
}
@@ -223,22 +265,22 @@ public class SettingsUtil {
}
};
- private final Class klass;
+ private final Class cla$$;
private final Function parser;
private final Function toString;
Parser() {
- this.klass = null;
+ this.cla$$ = null;
this.parser = null;
this.toString = null;
}
- Parser(Class klass, Function parser) {
- this(klass, parser, Object::toString);
+ Parser(Class cla$$, Function parser) {
+ this(cla$$, parser, Object::toString);
}
- Parser(Class klass, Function parser, Function toString) {
- this.klass = klass;
+ Parser(Class cla$$, Function parser, Function toString) {
+ this.cla$$ = cla$$;
this.parser = parser::apply;
this.toString = x -> toString.apply((T) x);
}
@@ -257,11 +299,11 @@ public class SettingsUtil {
@Override
public boolean accepts(Type type) {
- return type instanceof Class && this.klass.isAssignableFrom((Class) type);
+ return type instanceof Class && this.cla$$.isAssignableFrom((Class) type);
}
public static Parser getParser(Type type) {
- return Arrays.stream(values())
+ return Stream.of(values())
.filter(parser -> parser.accepts(type))
.findFirst().orElse(null);
}
diff --git a/src/api/java/baritone/api/utils/command/Command.java b/src/api/java/baritone/api/utils/command/Command.java
new file mode 100644
index 000000000..e83d6c50b
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/Command.java
@@ -0,0 +1,112 @@
+/*
+ * 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.command;
+
+import baritone.api.IBaritone;
+import baritone.api.utils.Helper;
+import baritone.api.utils.IPlayerContext;
+import baritone.api.utils.command.exception.CommandException;
+import baritone.api.utils.command.execution.ICommandExecution;
+import baritone.api.utils.command.helpers.arguments.ArgConsumer;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public abstract class Command implements Helper {
+
+ protected IBaritone baritone;
+ protected IPlayerContext ctx;
+
+ /**
+ * The names of this command. This is what you put after the command prefix.
+ */
+ public final List names;
+
+ /**
+ * Creates a new Baritone control command.
+ *
+ * @param names The names of this command. This is what you put after the command prefix.
+ */
+ protected Command(IBaritone baritone, List names) {
+ this.names = names.stream()
+ .map(s -> s.toLowerCase(Locale.US))
+ .collect(Collectors.toList());
+ this.baritone = baritone;
+ this.ctx = baritone.getPlayerContext();
+ }
+
+ protected Command(IBaritone baritone, String name) {
+ this(baritone, Collections.singletonList(name));
+ }
+
+ /**
+ * Executes this command with the specified arguments.
+ *
+ * @param execution The command execution to execute this command with
+ */
+ public final void execute(ICommandExecution execution) throws CommandException {
+ this.executed(execution.getLabel(), execution.getArguments());
+ }
+
+ /**
+ * Tab completes this command with the specified arguments. Any exception that is thrown by
+ * {@link #tabCompleted(String, ArgConsumer)} will be caught by this method, and then {@link Stream#empty()}
+ * will be returned.
+ *
+ * @param execution The command execution to tab complete
+ * @return The list of completions.
+ */
+ public final Stream tabComplete(ICommandExecution execution) {
+ try {
+ return this.tabCompleted(execution.getLabel(), execution.getArguments());
+ } catch (Throwable t) {
+ return Stream.empty();
+ }
+ }
+
+ /**
+ * Called when this command is executed.
+ */
+ protected abstract void executed(String label, ArgConsumer args) throws CommandException;
+
+ /**
+ * Called when the command needs to tab complete. Return a Stream representing the entries to put in the completions
+ * list.
+ */
+ protected abstract Stream tabCompleted(String label, ArgConsumer args) throws CommandException;
+
+ /**
+ * @return A single-line string containing a short description of this command's purpose.
+ */
+ public abstract String getShortDesc();
+
+ /**
+ * @return A list of lines that will be printed by the help command when the user wishes to view them.
+ */
+ public abstract List getLongDesc();
+
+ /**
+ * @return {@code true} if this command should be hidden from the help menu
+ */
+ public boolean hiddenFromHelp() {
+ return false;
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/IBaritoneChatControl.java b/src/api/java/baritone/api/utils/command/IBaritoneChatControl.java
new file mode 100644
index 000000000..63b6a4458
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/IBaritoneChatControl.java
@@ -0,0 +1,42 @@
+/*
+ * 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.command;
+
+import baritone.api.Settings;
+
+import java.util.UUID;
+
+/**
+ * @author Brady
+ * @since 9/26/2019
+ */
+public interface IBaritoneChatControl {
+
+ /**
+ * In certain cases chat components need to execute commands for you. For example, the paginator automatically runs
+ * commands when you click the forward and back arrows to show you the previous/next page.
+ *
+ * If the prefix is changed in the meantime, then the command will go to chat. That's no good. So here's a permanent
+ * prefix that forces a command to run, regardless of the current prefix, chat/prefix control being enabled, etc.
+ *
+ * If used right (by both developers and users), it should be impossible to expose a command accidentally to the
+ * server. As a rule of thumb, if you have a clickable chat component, always use this prefix. If you're suggesting
+ * a command (a component that puts text into your text box, or something else), use {@link Settings#prefix}.
+ */
+ String FORCE_COMMAND_PREFIX = String.format("<<%s>>", UUID.randomUUID().toString());
+}
diff --git a/src/api/java/baritone/api/utils/command/argparser/ArgParserManager.java b/src/api/java/baritone/api/utils/command/argparser/ArgParserManager.java
new file mode 100644
index 000000000..1b0730c60
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/argparser/ArgParserManager.java
@@ -0,0 +1,105 @@
+/*
+ * 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.command.argparser;
+
+import baritone.api.utils.command.argument.CommandArgument;
+import baritone.api.utils.command.exception.CommandInvalidTypeException;
+import baritone.api.utils.command.exception.CommandNoParserForTypeException;
+import baritone.api.utils.command.exception.CommandUnhandledException;
+import baritone.api.utils.command.registry.Registry;
+
+public class ArgParserManager {
+
+ public static final Registry REGISTRY = new Registry<>();
+
+ static {
+ DefaultArgParsers.ALL.forEach(REGISTRY::register);
+ }
+
+ /**
+ * @param type The type trying to be parsed
+ * @return A parser that can parse arguments into this class, if found.
+ */
+ public static IArgParser.Stateless getParserStateless(Class type) {
+ //noinspection unchecked
+ return REGISTRY.descendingStream()
+ .filter(IArgParser.Stateless.class::isInstance)
+ .map(IArgParser.Stateless.class::cast)
+ .filter(parser -> parser.getTarget().isAssignableFrom(type))
+ .findFirst()
+ .orElse(null);
+ }
+
+ /**
+ * @param type The type trying to be parsed
+ * @return A parser that can parse arguments into this class, if found.
+ */
+ public static IArgParser.Stated getParserStated(Class type, Class stateKlass) {
+ //noinspection unchecked
+ return REGISTRY.descendingStream()
+ .filter(IArgParser.Stated.class::isInstance)
+ .map(IArgParser.Stated.class::cast)
+ .filter(parser -> parser.getTarget().isAssignableFrom(type))
+ .filter(parser -> parser.getStateType().isAssignableFrom(stateKlass))
+ .map(IArgParser.Stated.class::cast)
+ .findFirst()
+ .orElse(null);
+ }
+
+ /**
+ * Attempt to parse the specified argument with a stateless {@link IArgParser} that outputs the specified class.
+ *
+ * @param type The type to try and parse the argument into.
+ * @param arg The argument to parse.
+ * @return An instance of the specified class.
+ * @throws CommandInvalidTypeException If the parsing failed
+ */
+ public static T parseStateless(Class type, CommandArgument arg) throws CommandInvalidTypeException {
+ IArgParser.Stateless parser = getParserStateless(type);
+ if (parser == null) {
+ throw new CommandNoParserForTypeException(type);
+ }
+ try {
+ return parser.parseArg(arg);
+ } catch (Exception exc) {
+ throw new CommandInvalidTypeException(arg, type.getSimpleName());
+ }
+ }
+
+ /**
+ * Attempt to parse the specified argument with a stated {@link IArgParser} that outputs the specified class.
+ *
+ * @param type The type to try and parse the argument into.
+ * @param arg The argument to parse.
+ * @param state The state to pass to the {@link IArgParser.Stated}.
+ * @return An instance of the specified class.
+ * @throws CommandInvalidTypeException If the parsing failed
+ * @see IArgParser.Stated
+ */
+ public static T parseStated(Class type, Class stateKlass, CommandArgument arg, S state) throws CommandInvalidTypeException {
+ IArgParser.Stated parser = getParserStated(type, stateKlass);
+ if (parser == null) {
+ throw new CommandNoParserForTypeException(type);
+ }
+ try {
+ return parser.parseArg(arg, state);
+ } catch (Exception exc) {
+ throw new CommandInvalidTypeException(arg, type.getSimpleName());
+ }
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/argparser/DefaultArgParsers.java b/src/api/java/baritone/api/utils/command/argparser/DefaultArgParsers.java
new file mode 100644
index 000000000..c33f61fbd
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/argparser/DefaultArgParsers.java
@@ -0,0 +1,123 @@
+/*
+ * 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.command.argparser;
+
+import baritone.api.utils.command.argument.CommandArgument;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Locale;
+
+public class DefaultArgParsers {
+
+ public enum IntArgumentParser implements IArgParser.Stateless {
+ INSTANCE;
+
+ @Override
+ public Class getTarget() {
+ return Integer.class;
+ }
+
+ @Override
+ public Integer parseArg(CommandArgument arg) throws RuntimeException {
+ return Integer.parseInt(arg.value);
+ }
+ }
+
+ public enum LongArgumentParser implements IArgParser.Stateless {
+ INSTANCE;
+
+ @Override
+ public Class getTarget() {
+ return Long.class;
+ }
+
+ @Override
+ public Long parseArg(CommandArgument arg) throws RuntimeException {
+ return Long.parseLong(arg.value);
+ }
+ }
+
+ public enum FloatArgumentParser implements IArgParser.Stateless {
+ INSTANCE;
+
+ @Override
+ public Class getTarget() {
+ return Float.class;
+ }
+
+ @Override
+ public Float parseArg(CommandArgument arg) throws RuntimeException {
+ String value = arg.value;
+ if (!value.matches("^([+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)|)$")) {
+ throw new IllegalArgumentException("failed float format check");
+ }
+ return Float.parseFloat(value);
+ }
+ }
+
+ public enum DoubleArgumentParser implements IArgParser.Stateless {
+ INSTANCE;
+
+ @Override
+ public Class getTarget() {
+ return Double.class;
+ }
+
+ @Override
+ public Double parseArg(CommandArgument arg) throws RuntimeException {
+ String value = arg.value;
+ if (!value.matches("^([+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)|)$")) {
+ throw new IllegalArgumentException("failed double format check");
+ }
+ return Double.parseDouble(value);
+ }
+ }
+
+ public static class BooleanArgumentParser implements IArgParser.Stateless {
+
+ public static final BooleanArgumentParser INSTANCE = new BooleanArgumentParser();
+ public static final List TRUTHY_VALUES = Arrays.asList("1", "true", "yes", "t", "y", "on", "enable");
+ public static final List FALSY_VALUES = Arrays.asList("0", "false", "no", "f", "n", "off", "disable");
+
+ @Override
+ public Class getTarget() {
+ return Boolean.class;
+ }
+
+ @Override
+ public Boolean parseArg(CommandArgument arg) throws RuntimeException {
+ String value = arg.value;
+ if (TRUTHY_VALUES.contains(value.toLowerCase(Locale.US))) {
+ return true;
+ } else if (FALSY_VALUES.contains(value.toLowerCase(Locale.US))) {
+ return false;
+ } else {
+ throw new IllegalArgumentException("invalid boolean");
+ }
+ }
+ }
+
+ public static final List> ALL = Arrays.asList(
+ IntArgumentParser.INSTANCE,
+ LongArgumentParser.INSTANCE,
+ FloatArgumentParser.INSTANCE,
+ DoubleArgumentParser.INSTANCE,
+ BooleanArgumentParser.INSTANCE
+ );
+}
diff --git a/src/api/java/baritone/api/utils/command/argparser/IArgParser.java b/src/api/java/baritone/api/utils/command/argparser/IArgParser.java
new file mode 100644
index 000000000..09e2aa2ea
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/argparser/IArgParser.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.utils.command.argparser;
+
+import baritone.api.utils.command.argument.CommandArgument;
+
+public interface IArgParser {
+
+ /**
+ * @return the class of this parser.
+ */
+ Class getTarget();
+
+ /**
+ * A stateless argument parser is just that. It takes a {@link CommandArgument} and outputs its type.
+ *
+ * @see ArgParserManager#REGISTRY
+ */
+ interface Stateless extends IArgParser {
+
+ /**
+ * @param arg The argument to parse.
+ * @return What it was parsed into.
+ * @throws RuntimeException if you want the parsing to fail. The exception will be caught and turned into an
+ * appropriate error.
+ */
+ T parseArg(CommandArgument arg) throws Exception;
+ }
+
+ /**
+ * A stated argument parser is similar to a stateless one. It also takes a {@link CommandArgument}, but it also
+ * takes a second argument that can be any type, referred to as the state.
+ *
+ * @see ArgParserManager#REGISTRY
+ */
+ interface Stated extends IArgParser {
+
+ Class getStateType();
+
+ /**
+ * @param arg The argument to parse.
+ * @param state Can be anything.
+ * @return What it was parsed into.
+ * @throws RuntimeException if you want the parsing to fail. The exception will be caught and turned into an
+ * appropriate error.
+ */
+ T parseArg(CommandArgument arg, S state) throws Exception;
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/argument/CommandArgument.java b/src/api/java/baritone/api/utils/command/argument/CommandArgument.java
new file mode 100644
index 000000000..a5b044c43
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/argument/CommandArgument.java
@@ -0,0 +1,170 @@
+/*
+ * 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.command.argument;
+
+import baritone.api.utils.command.argparser.ArgParserManager;
+import baritone.api.utils.command.argparser.IArgParser;
+import baritone.api.utils.command.exception.CommandInvalidArgumentException;
+import baritone.api.utils.command.exception.CommandInvalidTypeException;
+import baritone.api.utils.command.helpers.arguments.ArgConsumer;
+import net.minecraft.util.EnumFacing;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Stream;
+
+/**
+ * A {@link CommandArgument} is an immutable object representing one command argument. It contains data on the index of
+ * that argument, its value, and the rest of the string that argument was found in
+ *
+ * You're recommended to use {@link ArgConsumer}s to handle these.
+ */
+public class CommandArgument {
+
+ public final int index;
+ public final String value;
+ public final String rawRest;
+ public final static Pattern argPattern = Pattern.compile("\\S+");
+
+ private CommandArgument(int index, String value, String rawRest) {
+ this.index = index;
+ this.value = value;
+ this.rawRest = rawRest;
+ }
+
+ /**
+ * Gets an enum value from the enum class with the same name as this argument's value
+ *
+ * For example if you getEnum as an {@link EnumFacing}, and this argument's value is "up", it will return {@link
+ * EnumFacing#UP}
+ *
+ * @param enumClass The enum class to search
+ * @return An enum constant of that class with the same name as this argument's value
+ * @throws CommandInvalidTypeException If the constant couldn't be found
+ * @see ArgConsumer#peekEnum(Class)
+ * @see ArgConsumer#peekEnum(Class, int)
+ * @see ArgConsumer#peekEnumOrNull(Class)
+ * @see ArgConsumer#peekEnumOrNull(Class, int)
+ * @see ArgConsumer#getEnum(Class)
+ * @see ArgConsumer#getEnumOrNull(Class)
+ */
+ public > E getEnum(Class enumClass) throws CommandInvalidTypeException {
+ return Stream.of(enumClass.getEnumConstants())
+ .filter(e -> e.name().equalsIgnoreCase(value))
+ .findFirst()
+ .orElseThrow(() -> new CommandInvalidTypeException(this, enumClass.getSimpleName()));
+ }
+
+ /**
+ * Tries to use a stateless {@link IArgParser} to parse this argument into the specified class
+ *
+ * @param type The class to parse this argument into
+ * @return An instance of the specified type
+ * @throws CommandInvalidTypeException If the parsing failed
+ */
+ public T getAs(Class type) throws CommandInvalidTypeException {
+ return ArgParserManager.parseStateless(type, this);
+ }
+
+ /**
+ * Tries to use a stateless {@link IArgParser} to parse this argument into the specified class
+ *
+ * @param type The class to parse this argument into
+ * @return If the parser succeeded
+ */
+ public boolean is(Class type) {
+ try {
+ getAs(type);
+ return true;
+ } catch (Throwable t) {
+ return false;
+ }
+ }
+
+ /**
+ * Tries to use a stated {@link IArgParser} to parse this argument into the specified class
+ *
+ * @param type The class to parse this argument into
+ * @return An instance of the specified type
+ * @throws CommandInvalidTypeException If the parsing failed
+ */
+ @SuppressWarnings("UnusedReturnValue")
+ public T getAs(Class type, Class stateType, S state) throws CommandInvalidTypeException {
+ return ArgParserManager.parseStated(type, stateType, this, state);
+ }
+
+ /**
+ * Tries to use a stated {@link IArgParser} to parse this argument into the specified class
+ *
+ * @param type The class to parse this argument into
+ * @return If the parser succeeded
+ */
+ public boolean is(Class type, Class stateType, S state) {
+ try {
+ getAs(type, stateType, state);
+ return true;
+ } catch (Throwable t) {
+ return false;
+ }
+ }
+
+ /**
+ * Turn a string into a list of {@link CommandArgument}s. This is needed because of {@link CommandArgument#rawRest}
+ *
+ * @param string The string to convert
+ * @param preserveEmptyLast If the string ends with whitespace, add an empty {@link CommandArgument} to the end This
+ * is useful for tab completion
+ * @return A list of {@link CommandArgument}s
+ */
+ public static List from(String string, boolean preserveEmptyLast) {
+ List args = new ArrayList<>();
+ Matcher argMatcher = argPattern.matcher(string);
+ int lastEnd = -1;
+ while (argMatcher.find()) {
+ args.add(new CommandArgument(
+ args.size(),
+ argMatcher.group(),
+ string.substring(argMatcher.start())
+ ));
+ lastEnd = argMatcher.end();
+ }
+ if (preserveEmptyLast && lastEnd < string.length()) {
+ args.add(new CommandArgument(args.size(), "", ""));
+ }
+ return args;
+ }
+
+ /**
+ * @see #from(String, boolean)
+ */
+ public static List from(String string) {
+ return from(string, false);
+ }
+
+ /**
+ * Returns an "unknown" {@link CommandArgument}. This shouldn't be used unless you absolutely have no information -
+ * ESPECIALLY not with {@link CommandInvalidArgumentException}s
+ *
+ * @return The unknown {@link CommandArgument}
+ */
+ public static CommandArgument unknown() {
+ return new CommandArgument(-1, "", "");
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/datatypes/BlockById.java b/src/api/java/baritone/api/utils/command/datatypes/BlockById.java
new file mode 100644
index 000000000..750ff545d
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/datatypes/BlockById.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.api.utils.command.datatypes;
+
+import baritone.api.utils.command.exception.CommandException;
+import baritone.api.utils.command.helpers.tabcomplete.TabCompleteHelper;
+import net.minecraft.block.Block;
+import net.minecraft.init.Blocks;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.registry.IRegistry;
+
+import java.util.stream.Stream;
+
+public enum BlockById implements IDatatypeFor {
+ INSTANCE;
+
+ @Override
+ public Block get(IDatatypeContext ctx) throws CommandException {
+ ResourceLocation id = new ResourceLocation(ctx.getConsumer().getString());
+ Block block;
+ if ((block = IRegistry.BLOCK.get(id)) == Blocks.AIR) {
+ throw new IllegalArgumentException("no block found by that id");
+ }
+ return block;
+ }
+
+ @Override
+ public Stream tabComplete(IDatatypeContext ctx) throws CommandException {
+ return new TabCompleteHelper()
+ .append(
+ IRegistry.BLOCK.keySet()
+ .stream()
+ .map(Object::toString)
+ )
+ .filterPrefixNamespaced(ctx.getConsumer().getString())
+ .sortAlphabetically()
+ .stream();
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/datatypes/EntityClassById.java b/src/api/java/baritone/api/utils/command/datatypes/EntityClassById.java
new file mode 100644
index 000000000..87e58e509
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/datatypes/EntityClassById.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.utils.command.datatypes;
+
+import baritone.api.utils.command.exception.CommandException;
+import baritone.api.utils.command.helpers.tabcomplete.TabCompleteHelper;
+import net.minecraft.entity.EntityType;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.registry.IRegistry;
+
+import java.util.stream.Stream;
+
+public enum EntityClassById implements IDatatypeFor {
+ INSTANCE;
+
+ @Override
+ public EntityType get(IDatatypeContext ctx) throws CommandException {
+ ResourceLocation id = new ResourceLocation(ctx.getConsumer().getString());
+ EntityType entity;
+ if ((entity = IRegistry.ENTITY_TYPE.get(id)) == null) {
+ throw new IllegalArgumentException("no entity found by that id");
+ }
+ return entity;
+ }
+
+ @Override
+ public Stream tabComplete(IDatatypeContext ctx) throws CommandException {
+ return new TabCompleteHelper()
+ .append(IRegistry.ENTITY_TYPE.stream().map(Object::toString))
+ .filterPrefixNamespaced(ctx.getConsumer().getString())
+ .sortAlphabetically()
+ .stream();
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/datatypes/ForBlockOptionalMeta.java b/src/api/java/baritone/api/utils/command/datatypes/ForBlockOptionalMeta.java
new file mode 100644
index 000000000..f36826c6c
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/datatypes/ForBlockOptionalMeta.java
@@ -0,0 +1,37 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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.command.datatypes;
+
+import baritone.api.utils.BlockOptionalMeta;
+import baritone.api.utils.command.exception.CommandException;
+
+import java.util.stream.Stream;
+
+public enum ForBlockOptionalMeta implements IDatatypeFor {
+ INSTANCE;
+
+ @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);
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/datatypes/ForEnumFacing.java b/src/api/java/baritone/api/utils/command/datatypes/ForEnumFacing.java
new file mode 100644
index 000000000..ed6dce31b
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/datatypes/ForEnumFacing.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.utils.command.datatypes;
+
+import baritone.api.utils.command.exception.CommandException;
+import baritone.api.utils.command.helpers.tabcomplete.TabCompleteHelper;
+import net.minecraft.util.EnumFacing;
+
+import java.util.Locale;
+import java.util.stream.Stream;
+
+public enum ForEnumFacing implements IDatatypeFor {
+ INSTANCE;
+
+ @Override
+ public EnumFacing get(IDatatypeContext ctx) throws CommandException {
+ return EnumFacing.valueOf(ctx.getConsumer().getString().toUpperCase(Locale.US));
+ }
+
+ @Override
+ public Stream tabComplete(IDatatypeContext ctx) throws CommandException {
+ return new TabCompleteHelper()
+ .append(Stream.of(EnumFacing.values())
+ .map(EnumFacing::getName).map(String::toLowerCase))
+ .filterPrefix(ctx.getConsumer().getString())
+ .stream();
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/datatypes/ForWaypoints.java b/src/api/java/baritone/api/utils/command/datatypes/ForWaypoints.java
new file mode 100644
index 000000000..e60ff0c6a
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/datatypes/ForWaypoints.java
@@ -0,0 +1,81 @@
+/*
+ * 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.command.datatypes;
+
+import baritone.api.IBaritone;
+import baritone.api.cache.IWaypoint;
+import baritone.api.cache.IWaypointCollection;
+import baritone.api.utils.command.exception.CommandException;
+import baritone.api.utils.command.helpers.tabcomplete.TabCompleteHelper;
+
+import java.util.Comparator;
+import java.util.stream.Stream;
+
+public enum ForWaypoints implements IDatatypeFor {
+ INSTANCE;
+
+ @Override
+ public IWaypoint[] get(IDatatypeContext ctx) throws CommandException {
+ final String input = ctx.getConsumer().getString();
+ final IWaypoint.Tag tag = IWaypoint.Tag.getByName(input);
+
+ // If the input doesn't resolve to a valid tag, resolve by name
+ return tag == null
+ ? getWaypointsByName(ctx.getBaritone(), input)
+ : getWaypointsByTag(ctx.getBaritone(), tag);
+ }
+
+ @Override
+ public Stream tabComplete(IDatatypeContext ctx) throws CommandException {
+ return new TabCompleteHelper()
+ .append(getWaypointNames(ctx.getBaritone()))
+ .sortAlphabetically()
+ .prepend(IWaypoint.Tag.getAllNames())
+ .filterPrefix(ctx.getConsumer().getString())
+ .stream();
+ }
+
+ public static IWaypointCollection waypoints(IBaritone baritone) {
+ return baritone.getWorldProvider().getCurrentWorld().getWaypoints();
+ }
+
+ public static IWaypoint[] getWaypoints(IBaritone baritone) {
+ return waypoints(baritone).getAllWaypoints().stream()
+ .sorted(Comparator.comparingLong(IWaypoint::getCreationTimestamp).reversed())
+ .toArray(IWaypoint[]::new);
+ }
+
+ public static String[] getWaypointNames(IBaritone baritone) {
+ return Stream.of(getWaypoints(baritone))
+ .map(IWaypoint::getName)
+ .filter(name -> !name.isEmpty())
+ .toArray(String[]::new);
+ }
+
+ public static IWaypoint[] getWaypointsByTag(IBaritone baritone, IWaypoint.Tag tag) {
+ return waypoints(baritone).getByTag(tag).stream()
+ .sorted(Comparator.comparingLong(IWaypoint::getCreationTimestamp).reversed())
+ .toArray(IWaypoint[]::new);
+ }
+
+ public static IWaypoint[] getWaypointsByName(IBaritone baritone, String name) {
+ return Stream.of(getWaypoints(baritone))
+ .filter(waypoint -> waypoint.getName().equalsIgnoreCase(name))
+ .toArray(IWaypoint[]::new);
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/datatypes/IDatatype.java b/src/api/java/baritone/api/utils/command/datatypes/IDatatype.java
new file mode 100644
index 000000000..8c155fb68
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/datatypes/IDatatype.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.utils.command.datatypes;
+
+import baritone.api.utils.command.argparser.IArgParser;
+import baritone.api.utils.command.exception.CommandException;
+import baritone.api.utils.command.helpers.arguments.ArgConsumer;
+
+import java.util.stream.Stream;
+
+/**
+ * An {@link IDatatype} is similar to an {@link IArgParser} in the sense that it is capable of consuming an argument
+ * to transform it into a usable form as the code desires.
+ *
+ * A fundamental difference is that an {@link IDatatype} is capable of consuming multiple arguments. For example,
+ * {@link RelativeBlockPos} is an {@link IDatatypePost} which requires at least 3 {@link RelativeCoordinate} arguments
+ * to be specified.
+ *
+ * Another difference is that an {@link IDatatype} can be tab-completed, providing comprehensive auto completion
+ * that can substitute based on existing input or provide possibilities for the next piece of input.
+ *
+ * @see IDatatypeContext
+ * @see IDatatypeFor
+ * @see IDatatypePost
+ */
+public interface IDatatype {
+
+ /**
+ * Attempts to complete missing or partial input provided through the {@link ArgConsumer} provided by
+ * {@link IDatatypeContext#getConsumer()} in order to aide the user in executing commands.
+ *
+ * One benefit over datatypes over {@link IArgParser}s is that instead of each command trying to guess what values
+ * the datatype will accept, or simply not tab completing at all, datatypes that support tab completion can provide
+ * accurate information using the same methods used to parse arguments in the first place.
+ *
+ * @param ctx The argument consumer to tab complete
+ * @return A stream representing the strings that can be tab completed. DO NOT INCLUDE SPACES IN ANY STRINGS.
+ * @see ArgConsumer#tabCompleteDatatype(IDatatype)
+ */
+ Stream tabComplete(IDatatypeContext ctx) throws CommandException;
+}
diff --git a/src/api/java/baritone/api/utils/command/datatypes/IDatatypeContext.java b/src/api/java/baritone/api/utils/command/datatypes/IDatatypeContext.java
new file mode 100644
index 000000000..1452bf4ab
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/datatypes/IDatatypeContext.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.utils.command.datatypes;
+
+import baritone.api.IBaritone;
+import baritone.api.utils.command.helpers.arguments.ArgConsumer;
+
+/**
+ * Provides an {@link IDatatype} with contextual information so
+ * that it can perform the desired operation on the target level.
+ *
+ * @see IDatatype
+ *
+ * @author Brady
+ * @since 9/26/2019
+ */
+public interface IDatatypeContext {
+
+ /**
+ * Provides the {@link IBaritone} instance that is associated with the action relating to datatype handling.
+ *
+ * @return The context {@link IBaritone} instance.
+ */
+ IBaritone getBaritone();
+
+ /**
+ * Provides the {@link ArgConsumer} to fetch input information from.
+ *
+ * @return The context {@link ArgConsumer}.
+ */
+ ArgConsumer getConsumer();
+}
diff --git a/src/api/java/baritone/api/utils/command/datatypes/IDatatypeFor.java b/src/api/java/baritone/api/utils/command/datatypes/IDatatypeFor.java
new file mode 100644
index 000000000..4f0f42006
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/datatypes/IDatatypeFor.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.utils.command.datatypes;
+
+import baritone.api.utils.command.exception.CommandException;
+
+import java.util.function.Supplier;
+
+/**
+ * An {@link IDatatype} which acts as a {@link Supplier}, in essence. The only difference
+ * is that it requires an {@link IDatatypeContext} to be provided due to the expectation that
+ * implementations of {@link IDatatype} are singletons.
+ */
+public interface IDatatypeFor extends IDatatype {
+
+ /**
+ * Consumes the desired amount of arguments from the specified {@link IDatatypeContext}, and
+ * then returns the parsed value. This method will more than likely return a {@link IllegalArgumentException}
+ * if the expected input does not conform to a parseable value. As far as a {@link CommandException} being
+ * thrown is concerned, see the note below for specifics.
+ *
+ * @see IDatatypeContext
+ *
+ * @param ctx The context
+ * @return The parsed data-type
+ * @throws CommandException If there was an issue parsing using another type or arguments could not be polled.
+ */
+ T get(IDatatypeContext ctx) throws CommandException;
+}
diff --git a/src/api/java/baritone/api/utils/command/datatypes/IDatatypePost.java b/src/api/java/baritone/api/utils/command/datatypes/IDatatypePost.java
new file mode 100644
index 000000000..2e4cc47af
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/datatypes/IDatatypePost.java
@@ -0,0 +1,41 @@
+/*
+ * 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.command.datatypes;
+
+import baritone.api.utils.command.exception.CommandException;
+
+import java.util.function.Function;
+
+/**
+ * An {@link IDatatype} which acts as a {@link Function}, in essence. The only difference
+ * is that it requires an {@link IDatatypeContext} to be provided due to the expectation that
+ * implementations of {@link IDatatype} are singletons.
+ */
+public interface IDatatypePost extends IDatatype {
+
+ /**
+ * Takes the expected input and transforms it based on the value held by {@code original}. If {@code original}
+ * is null, it is expected that the implementation of this method has a case to handle it, such that a
+ * {@link NullPointerException} will never be thrown as a result.
+ *
+ * @param ctx The datatype context
+ * @param original The transformable value
+ * @return The transformed value
+ */
+ T apply(IDatatypeContext ctx, O original) throws CommandException;
+}
diff --git a/src/api/java/baritone/api/utils/command/datatypes/IDatatypePostFunction.java b/src/api/java/baritone/api/utils/command/datatypes/IDatatypePostFunction.java
new file mode 100644
index 000000000..a3de089e0
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/datatypes/IDatatypePostFunction.java
@@ -0,0 +1,29 @@
+/*
+ * 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.command.datatypes;
+
+import baritone.api.utils.command.exception.CommandException;
+
+/**
+ * @author Brady
+ * @since 9/26/2019
+ */
+public interface IDatatypePostFunction {
+
+ T apply(O original) throws CommandException;
+}
diff --git a/src/api/java/baritone/api/utils/command/datatypes/NearbyPlayer.java b/src/api/java/baritone/api/utils/command/datatypes/NearbyPlayer.java
new file mode 100644
index 000000000..4b91453d2
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/datatypes/NearbyPlayer.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.utils.command.datatypes;
+
+import baritone.api.IBaritone;
+import baritone.api.utils.command.exception.CommandException;
+import baritone.api.utils.command.helpers.tabcomplete.TabCompleteHelper;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.text.ITextComponent;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+/**
+ * An {@link IDatatype} used to resolve nearby players, those within
+ * render distance of the target {@link IBaritone} instance.
+ */
+public enum NearbyPlayer implements IDatatypeFor {
+ INSTANCE;
+
+ @Override
+ public EntityPlayer get(IDatatypeContext ctx) throws CommandException {
+ final String username = ctx.getConsumer().getString();
+ return getPlayers(ctx).stream()
+ .filter(s -> s.getName().toString().equalsIgnoreCase(username))
+ .findFirst().orElse(null);
+ }
+
+ @Override
+ public Stream tabComplete(IDatatypeContext ctx) throws CommandException {
+ return new TabCompleteHelper()
+ .append(getPlayers(ctx).stream().map(EntityPlayer::getName).map(ITextComponent::getString))
+ .filterPrefix(ctx.getConsumer().getString())
+ .sortAlphabetically()
+ .stream();
+ }
+
+ private static List getPlayers(IDatatypeContext ctx) {
+ return ctx.getBaritone().getPlayerContext().world().playerEntities;
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/datatypes/RelativeBlockPos.java b/src/api/java/baritone/api/utils/command/datatypes/RelativeBlockPos.java
new file mode 100644
index 000000000..8459db88d
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/datatypes/RelativeBlockPos.java
@@ -0,0 +1,57 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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.command.datatypes;
+
+import baritone.api.utils.BetterBlockPos;
+import baritone.api.utils.command.exception.CommandException;
+import baritone.api.utils.command.helpers.arguments.ArgConsumer;
+
+import java.util.stream.Stream;
+
+public enum RelativeBlockPos implements IDatatypePost {
+ INSTANCE;
+
+ @Override
+ public BetterBlockPos apply(IDatatypeContext ctx, BetterBlockPos origin) throws CommandException {
+ if (origin == null) {
+ origin = BetterBlockPos.ORIGIN;
+ }
+
+ final ArgConsumer consumer = ctx.getConsumer();
+ return new BetterBlockPos(
+ consumer.getDatatypePost(RelativeCoordinate.INSTANCE, (double) origin.x),
+ consumer.getDatatypePost(RelativeCoordinate.INSTANCE, (double) origin.y),
+ consumer.getDatatypePost(RelativeCoordinate.INSTANCE, (double) origin.z)
+ );
+ }
+
+ @Override
+ public Stream tabComplete(IDatatypeContext ctx) throws CommandException {
+ final ArgConsumer consumer = ctx.getConsumer();
+ if (consumer.hasAny() && !consumer.has(4)) {
+ while (consumer.has(2)) {
+ if (consumer.peekDatatypeOrNull(RelativeCoordinate.INSTANCE) == null) {
+ break;
+ }
+ consumer.get();
+ }
+ return consumer.tabCompleteDatatype(RelativeCoordinate.INSTANCE);
+ }
+ return Stream.empty();
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/datatypes/RelativeCoordinate.java b/src/api/java/baritone/api/utils/command/datatypes/RelativeCoordinate.java
new file mode 100644
index 000000000..84a29f63d
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/datatypes/RelativeCoordinate.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.utils.command.datatypes;
+
+import baritone.api.utils.command.exception.CommandException;
+import baritone.api.utils.command.helpers.arguments.ArgConsumer;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Stream;
+
+public enum RelativeCoordinate implements IDatatypePost {
+ INSTANCE;
+
+ private static Pattern PATTERN = Pattern.compile("^(~?)([+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)|)$");
+
+ @Override
+ public Double apply(IDatatypeContext ctx, Double origin) throws CommandException {
+ if (origin == null) {
+ origin = 0.0D;
+ }
+
+ Matcher matcher = PATTERN.matcher(ctx.getConsumer().getString());
+ if (!matcher.matches()) {
+ throw new IllegalArgumentException("pattern doesn't match");
+ }
+
+ boolean isRelative = !matcher.group(1).isEmpty();
+ double offset = matcher.group(2).isEmpty() ? 0 : Double.parseDouble(matcher.group(2));
+
+ if (isRelative) {
+ return origin + offset;
+ }
+ return offset;
+ }
+
+ @Override
+ public Stream tabComplete(IDatatypeContext ctx) throws CommandException {
+ final ArgConsumer consumer = ctx.getConsumer();
+ if (!consumer.has(2) && consumer.getString().matches("^(~|$)")) {
+ return Stream.of("~");
+ }
+ return Stream.empty();
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/datatypes/RelativeFile.java b/src/api/java/baritone/api/utils/command/datatypes/RelativeFile.java
new file mode 100644
index 000000000..71a9ca58c
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/datatypes/RelativeFile.java
@@ -0,0 +1,103 @@
+/*
+ * 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.command.datatypes;
+
+import baritone.api.utils.command.exception.CommandException;
+import baritone.api.utils.command.helpers.arguments.ArgConsumer;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.file.FileSystems;
+import java.nio.file.InvalidPathException;
+import java.nio.file.Path;
+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;
+
+ @Override
+ public File apply(IDatatypeContext ctx, File original) throws CommandException {
+ if (original == null) {
+ original = new File("./");
+ }
+
+ Path path;
+ try {
+ path = FileSystems.getDefault().getPath(ctx.getConsumer().getString());
+ } catch (InvalidPathException e) {
+ throw new IllegalArgumentException("invalid path");
+ }
+ return getCanonicalFileUnchecked(original.toPath().resolve(path).toFile());
+ }
+
+ @Override
+ public Stream tabComplete(IDatatypeContext ctx) {
+ return Stream.empty();
+ }
+
+ /**
+ * Seriously
+ *
+ * @param file File
+ * @return Canonical file of file
+ * @author LoganDark
+ */
+ private static File getCanonicalFileUnchecked(File file) {
+ try {
+ return file.getCanonicalFile();
+ } catch (IOException e) {
+ throw new UncheckedIOException(e);
+ }
+ }
+
+ public static Stream tabComplete(ArgConsumer consumer, File base0) throws CommandException {
+ // I will not make the caller deal with this, seriously
+ // Tab complete code is beautiful and I'm not going to bloat it with dumb ass checked exception bullshit -LoganDark
+
+ // lol owned -Brady
+
+ File base = getCanonicalFileUnchecked(base0);
+ String currentPathStringThing = consumer.getString();
+ Path currentPath = FileSystems.getDefault().getPath(currentPathStringThing);
+ Path basePath = currentPath.isAbsolute() ? currentPath.getRoot() : base.toPath();
+ boolean useParent = !currentPathStringThing.isEmpty() && !currentPathStringThing.endsWith(File.separator);
+ File currentFile = currentPath.isAbsolute() ? currentPath.toFile() : new File(base, currentPathStringThing);
+ return Stream.of(Objects.requireNonNull(getCanonicalFileUnchecked(
+ useParent
+ ? currentFile.getParentFile()
+ : currentFile
+ ).listFiles()))
+ .map(f -> (currentPath.isAbsolute() ? f : basePath.relativize(f.toPath()).toString()) +
+ (f.isDirectory() ? File.separator : ""))
+ .filter(s -> s.toLowerCase(Locale.US).startsWith(currentPathStringThing.toLowerCase(Locale.US)))
+ .filter(s -> !s.contains(" "));
+ }
+
+ public static File gameDir() {
+ File gameDir = HELPER.mc.gameDir.getAbsoluteFile();
+ if (gameDir.getName().equals(".")) {
+ return gameDir.getParentFile();
+ }
+ return gameDir;
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/datatypes/RelativeGoal.java b/src/api/java/baritone/api/utils/command/datatypes/RelativeGoal.java
new file mode 100644
index 000000000..d47e05ce4
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/datatypes/RelativeGoal.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.utils.command.datatypes;
+
+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.utils.BetterBlockPos;
+import baritone.api.utils.command.exception.CommandException;
+import baritone.api.utils.command.helpers.arguments.ArgConsumer;
+import net.minecraft.util.math.MathHelper;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Stream;
+
+public enum RelativeGoal implements IDatatypePost {
+ INSTANCE;
+
+ @Override
+ public Goal apply(IDatatypeContext ctx, BetterBlockPos origin) throws CommandException {
+ if (origin == null) {
+ origin = BetterBlockPos.ORIGIN;
+ }
+ final ArgConsumer consumer = ctx.getConsumer();
+
+ List> coords = new ArrayList<>();
+ final ArgConsumer copy = consumer.copy(); // This is a hack and should be fixed in the future probably
+ for (int i = 0; i < 3; i++) {
+ if (copy.peekDatatypeOrNull(RelativeCoordinate.INSTANCE) != null) {
+ coords.add(o -> consumer.getDatatypePost(RelativeCoordinate.INSTANCE, o));
+ copy.get(); // Consume so we actually decrement the remaining arguments
+ }
+ }
+
+ switch (coords.size()) {
+ case 0:
+ return new GoalBlock(origin);
+ case 1:
+ return new GoalYLevel(
+ MathHelper.floor(coords.get(0).apply((double) origin.y))
+ );
+ case 2:
+ return new GoalXZ(
+ MathHelper.floor(coords.get(0).apply((double) origin.x)),
+ MathHelper.floor(coords.get(1).apply((double) origin.z))
+ );
+ case 3:
+ return new GoalBlock(
+ MathHelper.floor(coords.get(0).apply((double) origin.x)),
+ MathHelper.floor(coords.get(1).apply((double) origin.y)),
+ MathHelper.floor(coords.get(2).apply((double) origin.z))
+ );
+ default:
+ throw new IllegalStateException("Unexpected coords size: " + coords.size());
+ }
+ }
+
+ @Override
+ public Stream tabComplete(IDatatypeContext ctx) {
+ return ctx.getConsumer().tabCompleteDatatype(RelativeCoordinate.INSTANCE);
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/datatypes/RelativeGoalBlock.java b/src/api/java/baritone/api/utils/command/datatypes/RelativeGoalBlock.java
new file mode 100644
index 000000000..cd1c0be10
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/datatypes/RelativeGoalBlock.java
@@ -0,0 +1,53 @@
+/*
+ * 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.command.datatypes;
+
+import baritone.api.pathing.goals.GoalBlock;
+import baritone.api.utils.BetterBlockPos;
+import baritone.api.utils.command.exception.CommandException;
+import baritone.api.utils.command.helpers.arguments.ArgConsumer;
+import net.minecraft.util.math.MathHelper;
+
+import java.util.stream.Stream;
+
+public enum RelativeGoalBlock implements IDatatypePost {
+ INSTANCE;
+
+ @Override
+ public GoalBlock apply(IDatatypeContext ctx, BetterBlockPos origin) throws CommandException {
+ if (origin == null) {
+ origin = BetterBlockPos.ORIGIN;
+ }
+
+ final ArgConsumer consumer = ctx.getConsumer();
+ return new GoalBlock(
+ MathHelper.floor(consumer.getDatatypePost(RelativeCoordinate.INSTANCE, (double) origin.x)),
+ MathHelper.floor(consumer.getDatatypePost(RelativeCoordinate.INSTANCE, (double) origin.y)),
+ MathHelper.floor(consumer.getDatatypePost(RelativeCoordinate.INSTANCE, (double) origin.z))
+ );
+ }
+
+ @Override
+ public Stream tabComplete(IDatatypeContext ctx) {
+ final ArgConsumer consumer = ctx.getConsumer();
+ if (consumer.hasAtMost(3)) {
+ return consumer.tabCompleteDatatype(RelativeCoordinate.INSTANCE);
+ }
+ return Stream.empty();
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/datatypes/RelativeGoalXZ.java b/src/api/java/baritone/api/utils/command/datatypes/RelativeGoalXZ.java
new file mode 100644
index 000000000..b8bd0cd62
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/datatypes/RelativeGoalXZ.java
@@ -0,0 +1,52 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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.command.datatypes;
+
+import baritone.api.pathing.goals.GoalXZ;
+import baritone.api.utils.BetterBlockPos;
+import baritone.api.utils.command.exception.CommandException;
+import baritone.api.utils.command.helpers.arguments.ArgConsumer;
+import net.minecraft.util.math.MathHelper;
+
+import java.util.stream.Stream;
+
+public enum RelativeGoalXZ implements IDatatypePost {
+ INSTANCE;
+
+ @Override
+ public GoalXZ apply(IDatatypeContext ctx, BetterBlockPos origin) throws CommandException {
+ if (origin == null) {
+ origin = BetterBlockPos.ORIGIN;
+ }
+
+ final ArgConsumer consumer = ctx.getConsumer();
+ return new GoalXZ(
+ MathHelper.floor(consumer.getDatatypePost(RelativeCoordinate.INSTANCE, (double) origin.x)),
+ MathHelper.floor(consumer.getDatatypePost(RelativeCoordinate.INSTANCE, (double) origin.y))
+ );
+ }
+
+ @Override
+ public Stream tabComplete(IDatatypeContext ctx) {
+ final ArgConsumer consumer = ctx.getConsumer();
+ if (consumer.hasAtMost(2)) {
+ return consumer.tabCompleteDatatype(RelativeCoordinate.INSTANCE);
+ }
+ return Stream.empty();
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/datatypes/RelativeGoalYLevel.java b/src/api/java/baritone/api/utils/command/datatypes/RelativeGoalYLevel.java
new file mode 100644
index 000000000..a8a9b232e
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/datatypes/RelativeGoalYLevel.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.utils.command.datatypes;
+
+import baritone.api.pathing.goals.GoalYLevel;
+import baritone.api.utils.BetterBlockPos;
+import baritone.api.utils.command.exception.CommandException;
+import baritone.api.utils.command.helpers.arguments.ArgConsumer;
+import net.minecraft.util.math.MathHelper;
+
+import java.util.stream.Stream;
+
+public enum RelativeGoalYLevel implements IDatatypePost {
+ INSTANCE;
+
+ @Override
+ public GoalYLevel apply(IDatatypeContext ctx, BetterBlockPos origin) throws CommandException {
+ if (origin == null) {
+ origin = BetterBlockPos.ORIGIN;
+ }
+
+ return new GoalYLevel(
+ MathHelper.floor(ctx.getConsumer().getDatatypePost(RelativeCoordinate.INSTANCE, (double) origin.y))
+ );
+ }
+
+ @Override
+ public Stream tabComplete(IDatatypeContext ctx) {
+ final ArgConsumer consumer = ctx.getConsumer();
+ if (consumer.hasAtMost(1)) {
+ return consumer.tabCompleteDatatype(RelativeCoordinate.INSTANCE);
+ }
+ return Stream.empty();
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/exception/CommandErrorMessageException.java b/src/api/java/baritone/api/utils/command/exception/CommandErrorMessageException.java
new file mode 100644
index 000000000..002d328e1
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/exception/CommandErrorMessageException.java
@@ -0,0 +1,25 @@
+/*
+ * 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.command.exception;
+
+public abstract class CommandErrorMessageException extends CommandException {
+
+ protected CommandErrorMessageException(String reason) {
+ super(reason);
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/exception/CommandException.java b/src/api/java/baritone/api/utils/command/exception/CommandException.java
new file mode 100644
index 000000000..9fdc3f735
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/exception/CommandException.java
@@ -0,0 +1,25 @@
+/*
+ * 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.command.exception;
+
+public abstract class CommandException extends Exception implements ICommandException {
+
+ protected CommandException(String reason) {
+ super(reason);
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/exception/CommandInvalidArgumentException.java b/src/api/java/baritone/api/utils/command/exception/CommandInvalidArgumentException.java
new file mode 100644
index 000000000..627067051
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/exception/CommandInvalidArgumentException.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.api.utils.command.exception;
+
+import baritone.api.utils.command.argument.CommandArgument;
+
+public abstract class CommandInvalidArgumentException extends CommandErrorMessageException {
+
+ public final CommandArgument arg;
+
+ protected CommandInvalidArgumentException(CommandArgument arg, String reason) {
+ super(String.format(
+ "Error at argument #%s: %s",
+ arg.index == -1 ? "" : Integer.toString(arg.index + 1),
+ reason
+ ));
+ this.arg = arg;
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/exception/CommandInvalidStateException.java b/src/api/java/baritone/api/utils/command/exception/CommandInvalidStateException.java
new file mode 100644
index 000000000..4e00c1f7f
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/exception/CommandInvalidStateException.java
@@ -0,0 +1,25 @@
+/*
+ * 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.command.exception;
+
+public class CommandInvalidStateException extends CommandErrorMessageException {
+
+ public CommandInvalidStateException(String reason) {
+ super(reason);
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/exception/CommandInvalidTypeException.java b/src/api/java/baritone/api/utils/command/exception/CommandInvalidTypeException.java
new file mode 100644
index 000000000..5e5b81cdd
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/exception/CommandInvalidTypeException.java
@@ -0,0 +1,39 @@
+/*
+ * 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.command.exception;
+
+import baritone.api.utils.command.argument.CommandArgument;
+
+public class CommandInvalidTypeException extends CommandInvalidArgumentException {
+
+ public CommandInvalidTypeException(CommandArgument arg, String expected) {
+ super(arg, String.format("Expected %s", expected));
+ }
+
+ public CommandInvalidTypeException(CommandArgument arg, String expected, Throwable cause) {
+ super(arg, String.format("Expected %s.\nMore details: %s", expected, cause.getMessage()));
+ }
+
+ public CommandInvalidTypeException(CommandArgument arg, String expected, String got) {
+ super(arg, String.format("Expected %s, but got %s instead", expected, got));
+ }
+
+ public CommandInvalidTypeException(CommandArgument arg, String expected, String got, Throwable cause) {
+ super(arg, String.format("Expected %s, but got %s instead.\nMore details: %s", expected, got, cause.getMessage()));
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/exception/CommandNoParserForTypeException.java b/src/api/java/baritone/api/utils/command/exception/CommandNoParserForTypeException.java
new file mode 100644
index 000000000..f4f2d8181
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/exception/CommandNoParserForTypeException.java
@@ -0,0 +1,25 @@
+/*
+ * 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.command.exception;
+
+public class CommandNoParserForTypeException extends CommandUnhandledException {
+
+ public CommandNoParserForTypeException(Class klass) {
+ super(String.format("Could not find a handler for type %s", klass.getSimpleName()));
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/exception/CommandNotEnoughArgumentsException.java b/src/api/java/baritone/api/utils/command/exception/CommandNotEnoughArgumentsException.java
new file mode 100644
index 000000000..655652d6c
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/exception/CommandNotEnoughArgumentsException.java
@@ -0,0 +1,25 @@
+/*
+ * 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.command.exception;
+
+public class CommandNotEnoughArgumentsException extends CommandErrorMessageException {
+
+ public CommandNotEnoughArgumentsException(int minArgs) {
+ super(String.format("Not enough arguments (expected at least %d)", minArgs));
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/exception/CommandNotFoundException.java b/src/api/java/baritone/api/utils/command/exception/CommandNotFoundException.java
new file mode 100644
index 000000000..e8904cbc8
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/exception/CommandNotFoundException.java
@@ -0,0 +1,40 @@
+/*
+ * 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.command.exception;
+
+import baritone.api.utils.command.Command;
+import baritone.api.utils.command.argument.CommandArgument;
+
+import java.util.List;
+
+import static baritone.api.utils.Helper.HELPER;
+
+public class CommandNotFoundException extends CommandException {
+
+ public final String command;
+
+ public CommandNotFoundException(String command) {
+ super(String.format("Command not found: %s", command));
+ this.command = command;
+ }
+
+ @Override
+ public void handle(Command command, List args) {
+ HELPER.logDirect(getMessage());
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/exception/CommandTooManyArgumentsException.java b/src/api/java/baritone/api/utils/command/exception/CommandTooManyArgumentsException.java
new file mode 100644
index 000000000..24fc799fe
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/exception/CommandTooManyArgumentsException.java
@@ -0,0 +1,25 @@
+/*
+ * 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.command.exception;
+
+public class CommandTooManyArgumentsException extends CommandErrorMessageException {
+
+ public CommandTooManyArgumentsException(int maxArgs) {
+ super(String.format("Too many arguments (expected at most %d)", maxArgs));
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/exception/CommandUnhandledException.java b/src/api/java/baritone/api/utils/command/exception/CommandUnhandledException.java
new file mode 100644
index 000000000..6d647a201
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/exception/CommandUnhandledException.java
@@ -0,0 +1,46 @@
+/*
+ * 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.command.exception;
+
+import baritone.api.utils.command.Command;
+import baritone.api.utils.command.argument.CommandArgument;
+import net.minecraft.util.text.TextFormatting;
+
+import java.util.List;
+
+import static baritone.api.utils.Helper.HELPER;
+
+public class CommandUnhandledException extends RuntimeException implements ICommandException {
+
+ public CommandUnhandledException(String message) {
+ super(message);
+ }
+
+ public CommandUnhandledException(Throwable cause) {
+ super(cause);
+ }
+
+ @Override
+ public void handle(Command 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",
+ TextFormatting.RED);
+
+ this.printStackTrace();
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/exception/ICommandException.java b/src/api/java/baritone/api/utils/command/exception/ICommandException.java
new file mode 100644
index 000000000..379e97b7f
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/exception/ICommandException.java
@@ -0,0 +1,55 @@
+/*
+ * 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.command.exception;
+
+import baritone.api.utils.command.Command;
+import baritone.api.utils.command.argument.CommandArgument;
+import net.minecraft.util.text.TextFormatting;
+
+import java.util.List;
+
+import static baritone.api.utils.Helper.HELPER;
+
+/**
+ * The base for a Baritone Command Exception, checked or unchecked. Provides a
+ * {@link #handle(Command, List)} method that is used to provide useful output
+ * to the user for diagnosing issues that may have occurred during execution.
+ *
+ * Anything implementing this interface should be assignable to {@link Exception}.
+ *
+ * @author Brady
+ * @since 9/20/2019
+ */
+public interface ICommandException {
+
+ /**
+ * @see Exception#getMessage()
+ * @return The exception details
+ */
+ String getMessage();
+
+ /**
+ * Called when this exception is thrown, to handle the exception.
+ *
+ * @param command The command that threw it.
+ * @param args The arguments the command was called with.
+ */
+ default void handle(Command command, List args) {
+ HELPER.logDirect(this.getMessage(), TextFormatting.RED);
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/execution/ICommandExecution.java b/src/api/java/baritone/api/utils/command/execution/ICommandExecution.java
new file mode 100644
index 000000000..4ca5b193c
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/execution/ICommandExecution.java
@@ -0,0 +1,68 @@
+/*
+ * 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.command.execution;
+
+import baritone.api.utils.command.Command;
+import baritone.api.utils.command.argument.CommandArgument;
+import baritone.api.utils.command.helpers.arguments.ArgConsumer;
+import net.minecraft.util.Tuple;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+/**
+ * @author Brady
+ * @since 9/28/2019
+ */
+public interface ICommandExecution {
+
+ /**
+ * @return The label that was used to target the {@link Command}
+ */
+ String getLabel();
+
+ /**
+ * @return The arguments to be passed to the {@link Command}
+ */
+ ArgConsumer getArguments();
+
+ /**
+ * Executes the target command for this {@link ICommandExecution}. This method should never
+ * {@code throw} any exception, anything that is thrown during the target command execution
+ * should be safely handled.
+ */
+ void execute();
+
+ /**
+ * Forwards this {@link ICommandExecution} to the target {@link Command} to perform a tab-completion.
+ * If the tab-completion operation is a failure, then {@link Stream#empty()} will be returned.
+ *
+ * @return The tab-completed arguments, if possible.
+ */
+ Stream tabComplete();
+
+ static Tuple> expand(String string, boolean preserveEmptyLast) {
+ String label = string.split("\\s", 2)[0];
+ List args = CommandArgument.from(string.substring(label.length()), preserveEmptyLast);
+ return new Tuple<>(label, args);
+ }
+
+ static Tuple> expand(String string) {
+ return expand(string, false);
+ }
+}
diff --git a/src/api/java/baritone/api/utils/command/helpers/arguments/ArgConsumer.java b/src/api/java/baritone/api/utils/command/helpers/arguments/ArgConsumer.java
new file mode 100644
index 000000000..e92855d1d
--- /dev/null
+++ b/src/api/java/baritone/api/utils/command/helpers/arguments/ArgConsumer.java
@@ -0,0 +1,818 @@
+/*
+ * 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.command.helpers.arguments;
+
+import baritone.api.IBaritone;
+import baritone.api.utils.Helper;
+import baritone.api.utils.command.Command;
+import baritone.api.utils.command.argparser.IArgParser;
+import baritone.api.utils.command.argument.CommandArgument;
+import baritone.api.utils.command.datatypes.IDatatype;
+import baritone.api.utils.command.datatypes.IDatatypeContext;
+import baritone.api.utils.command.datatypes.IDatatypeFor;
+import baritone.api.utils.command.datatypes.IDatatypePost;
+import baritone.api.utils.command.exception.CommandException;
+import baritone.api.utils.command.exception.CommandInvalidTypeException;
+import baritone.api.utils.command.exception.CommandNotEnoughArgumentsException;
+import baritone.api.utils.command.exception.CommandTooManyArgumentsException;
+import baritone.api.utils.command.manager.ICommandManager;
+import net.minecraft.util.EnumFacing;
+
+import java.util.ArrayList;
+import java.util.Deque;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.stream.Stream;
+
+/**
+ * The {@link ArgConsumer} is how {@link Command}s read the arguments passed to them. This class has many benefits:
+ *
+ *
+ * - Mutability. The whole concept of the {@link ArgConsumer} is to let you gradually consume arguments in any way
+ * you'd like. You can change your consumption based on earlier arguments, for subcommands for example.
+ * - You don't need to keep track of your consumption. The {@link ArgConsumer} keeps track of the arguments you
+ * consume so that it can throw detailed exceptions whenever something is out of the ordinary. Additionally, if you
+ * need to retrieve an argument after you've already consumed it - look no further than {@link #consumed()}!
+ * - Easy retrieval of many different types. If you need to retrieve an instance of an int or float for example,
+ * look no further than {@link #getAs(Class)}. If you need a more powerful way of retrieving data, try out the many
+ * {@code getDatatype...} methods.
+ * - It's very easy to throw detailed exceptions. The {@link ArgConsumer} has many different methods that can
+ * enforce the number of arguments, the type of arguments, and more, throwing different types of
+ * {@link CommandException}s if something seems off. You're recommended to do all validation and store all needed
+ * data in variables BEFORE logging any data to chat via {@link Helper#logDirect(String)}, so that the error
+ * handlers can do their job and log the error to chat.
+ *
+ */
+public class ArgConsumer {
+
+ /**
+ * The parent {@link ICommandManager} for this {@link ArgConsumer}. Used by {@link #context}.
+ */
+ private final ICommandManager manager;
+
+ /**
+ * The {@link IDatatypeContext} instance for this {@link ArgConsumer}, passed to
+ * datatypes when an operation is performed upon them.
+ *
+ * @see IDatatype
+ * @see IDatatypeContext
+ */
+ private final IDatatypeContext context;
+
+ /**
+ * The list of arguments in this ArgConsumer
+ */
+ public final LinkedList args;
+
+ /**
+ * The list of consumed arguments for this ArgConsumer. The most recently consumed argument is the last one
+ */
+ public final Deque consumed;
+
+ private ArgConsumer(ICommandManager manager, Deque args, Deque consumed) {
+ this.manager = manager;
+ this.context = this.new Context();
+ this.args = new LinkedList<>(args);
+ this.consumed = new LinkedList<>(consumed);
+ }
+
+ public ArgConsumer(ICommandManager manager, List args) {
+ this(manager, new LinkedList<>(args), new LinkedList<>());
+ }
+
+ /**
+ * @param num The number of arguments to check for
+ * @return {@code true} if there are at least {@code num} arguments left in this {@link ArgConsumer}
+ * @see #hasAny()
+ * @see #hasAtMost(int)
+ * @see #hasExactly(int)
+ */
+ public boolean has(int num) {
+ return args.size() >= num;
+ }
+
+ /**
+ * @return {@code true} if there is at least 1 argument left in this {@link ArgConsumer}
+ * @see #has(int)
+ * @see #hasAtMostOne()
+ * @see #hasExactlyOne()
+ */
+ public boolean hasAny() {
+ return has(1);
+ }
+
+ /**
+ * @param num The number of arguments to check for
+ * @return {@code true} if there are at most {@code num} arguments left in this {@link ArgConsumer}
+ * @see #has(int)
+ * @see #hasAtMost(int)
+ * @see #hasExactly(int)
+ */
+ public boolean hasAtMost(int num) {
+ return args.size() <= num;
+ }
+
+ /**
+ * @return {@code true} if there is at most 1 argument left in this {@link ArgConsumer}
+ * @see #hasAny()
+ * @see #hasAtMostOne()
+ * @see #hasExactlyOne()
+ */
+ public boolean hasAtMostOne() {
+ return hasAtMost(1);
+ }
+
+ /**
+ * @param num The number of arguments to check for
+ * @return {@code true} if there are exactly {@code num} arguments left in this {@link ArgConsumer}
+ * @see #has(int)
+ * @see #hasAtMost(int)
+ */
+ public boolean hasExactly(int num) {
+ return args.size() == num;
+ }
+
+ /**
+ * @return {@code true} if there is exactly 1 argument left in this {@link ArgConsumer}
+ * @see #hasAny()
+ * @see #hasAtMostOne()
+ */
+ public boolean hasExactlyOne() {
+ return hasExactly(1);
+ }
+
+ /**
+ * @param index The index to peek
+ * @return The argument at index {@code index} in this {@link ArgConsumer}, with 0 being the next one. This does not
+ * mutate the {@link ArgConsumer}
+ * @throws CommandNotEnoughArgumentsException If there is less than {@code index + 1} arguments left
+ * @see #peek()
+ * @see #peekString(int)
+ * @see #peekAs(Class, int)
+ * @see #get()
+ */
+ public CommandArgument peek(int index) throws CommandNotEnoughArgumentsException {
+ requireMin(index + 1);
+ return args.get(index);
+ }
+
+ /**
+ * @return The next argument in this {@link ArgConsumer}. This does not mutate the {@link ArgConsumer}
+ * @throws CommandNotEnoughArgumentsException If there is less than one argument left
+ * @see #peek(int)
+ * @see #peekString()
+ * @see #peekAs(Class)
+ * @see #get()
+ */
+ public CommandArgument peek() throws CommandNotEnoughArgumentsException {
+ return peek(0);
+ }
+
+ /**
+ * @param index The index to peek
+ * @param type The type to check for
+ * @return If an ArgParser.Stateless for the specified {@code type} would succeed in parsing the next
+ * argument
+ * @throws CommandNotEnoughArgumentsException If there is less than {@code index + 1} arguments left
+ * @see #peek()
+ * @see #getAs(Class)
+ */
+ public boolean is(Class type, int index) throws CommandNotEnoughArgumentsException {
+ return peek(index).is(type);
+ }
+
+ /**
+ * @param type The type to check for
+ * @return If an ArgParser.Stateless for the specified {@code type} would succeed in parsing the next
+ * argument
+ * @throws CommandNotEnoughArgumentsException If there is less than one argument left
+ * @see #peek()
+ * @see #getAs(Class)
+ */
+ public boolean is(Class type) throws CommandNotEnoughArgumentsException {
+ return is(type, 0);
+ }
+
+ /**
+ * @param index The index to peek
+ * @return The value of the argument at index {@code index} in this {@link ArgConsumer}, with 0 being the next one
+ * This does not mutate the {@link ArgConsumer}
+ * @throws CommandNotEnoughArgumentsException If there is less than {@code index + 1} arguments left
+ * @see #peek()
+ * @see #peekString()
+ */
+ public String peekString(int index) throws CommandNotEnoughArgumentsException {
+ return peek(index).value;
+ }
+
+ /**
+ * @return The value of the next argument in this {@link ArgConsumer}. This does not mutate the {@link ArgConsumer}
+ * @throws CommandNotEnoughArgumentsException If there is less than one argument left
+ * @see #peekString(int)
+ * @see #getString()
+ */
+ public String peekString() throws CommandNotEnoughArgumentsException {
+ return peekString(0);
+ }
+
+ /**
+ * @param index The index to peek
+ * @param enumClass The class to search
+ * @return From the specified enum class, an enum constant of that class. The enum constant's name will match the
+ * next argument's value
+ * @throws java.util.NoSuchElementException If the constant couldn't be found
+ * @see #peekEnumOrNull(Class)
+ * @see #getEnum(Class)
+ * @see CommandArgument#getEnum(Class)
+ */
+ public > E peekEnum(Class enumClass, int index) throws CommandInvalidTypeException, CommandNotEnoughArgumentsException {
+ return peek(index).getEnum(enumClass);
+ }
+
+ /**
+ * @param enumClass The class to search
+ * @return From the specified enum class, an enum constant of that class. The enum constant's name will match the
+ * next argument's value
+ * @throws CommandInvalidTypeException If the constant couldn't be found
+ * @see #peekEnumOrNull(Class)
+ * @see #getEnum(Class)
+ * @see CommandArgument#getEnum(Class)
+ */
+ public > E peekEnum(Class enumClass) throws CommandInvalidTypeException, CommandNotEnoughArgumentsException {
+ return peekEnum(enumClass, 0);
+ }
+
+ /**
+ * @param index The index to peek
+ * @param enumClass The class to search
+ * @return From the specified enum class, an enum constant of that class. The enum constant's name will match the
+ * next argument's value. If no constant could be found, null
+ * @see #peekEnum(Class)
+ * @see #getEnumOrNull(Class)
+ * @see CommandArgument#getEnum(Class)
+ */
+ public > E peekEnumOrNull(Class enumClass, int index) throws CommandNotEnoughArgumentsException {
+ try {
+ return peekEnum(enumClass, index);
+ } catch (CommandInvalidTypeException e) {
+ return null;
+ }
+ }
+
+ /**
+ * @param enumClass The class to search
+ * @return From the specified enum class, an enum constant of that class. The enum constant's name will match the
+ * next argument's value. If no constant could be found, null
+ * @see #peekEnum(Class)
+ * @see #getEnumOrNull(Class)
+ * @see CommandArgument#getEnum(Class)
+ */
+ public > E peekEnumOrNull(Class enumClass) throws CommandNotEnoughArgumentsException {
+ return peekEnumOrNull(enumClass, 0);
+ }
+
+ /**
+ * Tries to use a stateless {@link IArgParser} to parse the argument at the specified index into the specified
+ * class
+ *
+ * A critical difference between {@link IDatatype}s and {@link IArgParser}s is how many arguments they can take.
+ * While {@link IArgParser}s always operate on a single argument's value, {@link IDatatype}s get access to the entire
+ * {@link ArgConsumer}.
+ *
+ * @param type The type to peek as
+ * @param index The index to peek
+ * @return An instance of the specified type
+ * @throws CommandInvalidTypeException If the parsing failed
+ * @see IArgParser
+ * @see #peekAs(Class)
+ * @see #peekAsOrDefault(Class, Object, int)
+ * @see #peekAsOrNull(Class, int)
+ */
+ public T peekAs(Class type, int index) throws CommandInvalidTypeException, CommandNotEnoughArgumentsException {
+ return peek(index).getAs(type);
+ }
+
+ /**
+ * Tries to use a stateless {@link IArgParser} to parse the next argument into the specified class
+ *
+ * A critical difference between {@link IDatatype}s and {@link IArgParser}s is how many arguments they can take.
+ * While {@link IArgParser}s always operate on a single argument's value, {@link IDatatype}s get access to the entire
+ * {@link ArgConsumer}.
+ *
+ * @param type The type to peek as
+ * @return An instance of the specified type
+ * @throws CommandInvalidTypeException If the parsing failed
+ * @see IArgParser
+ * @see #peekAs(Class, int)
+ * @see #peekAsOrDefault(Class, Object)
+ * @see #peekAsOrNull(Class)
+ */
+ public T peekAs(Class type) throws CommandInvalidTypeException, CommandNotEnoughArgumentsException {
+ return peekAs(type, 0);
+ }
+
+ /**
+ * Tries to use a stateless {@link IArgParser} to parse the argument at the specified index into the specified
+ * class
+ *
+ * A critical difference between {@link IDatatype}s and {@link IArgParser}s is how many arguments they can take.
+ * While {@link IArgParser}s always operate on a single argument's value, {@link IDatatype}s get access to the entire
+ * {@link ArgConsumer}.
+ *
+ * @param type The type to peek as
+ * @param def The value to return if the argument can't be parsed
+ * @param index The index to peek
+ * @return An instance of the specified type, or {@code def} if it couldn't be parsed
+ * @see IArgParser
+ * @see #peekAsOrDefault(Class, Object)
+ * @see #peekAs(Class, int)
+ * @see #peekAsOrNull(Class, int)
+ */
+ public T peekAsOrDefault(Class type, T def, int index) throws CommandNotEnoughArgumentsException {
+ try {
+ return peekAs(type, index);
+ } catch (CommandInvalidTypeException e) {
+ return def;
+ }
+ }
+
+ /**
+ * Tries to use a stateless {@link IArgParser} to parse the next argument into the specified class
+ *
+ * A critical difference between {@link IDatatype}s and {@link IArgParser}s is how many arguments they can take.
+ * While {@link IArgParser}s always operate on a single argument's value, {@link IDatatype}s get access to the entire
+ * {@link ArgConsumer}.
+ *
+ * @param type The type to peek as
+ * @param def The value to return if the argument can't be parsed
+ * @return An instance of the specified type, or {@code def} if it couldn't be parsed
+ * @see IArgParser
+ * @see #peekAsOrDefault(Class, Object, int)
+ * @see #peekAs(Class)
+ * @see #peekAsOrNull(Class)
+ */
+ public T peekAsOrDefault(Class type, T def) throws CommandNotEnoughArgumentsException {
+ return peekAsOrDefault(type, def, 0);
+ }
+
+ /**
+ * Tries to use a