Add Crafting command

src/api/java/baritone/api/IBaritone.java

@@ -88,6 +88,12 @@ public interface IBaritone {
      */
     IGetToBlockProcess getGetToBlockProcess();
 
+    /**
+     * @return The {@link IGetToBlockProcess} instance
+     * @see IGetToBlockProcess
+     */
+    ICraftingProcess getCraftingProcess();
+
     /**
      * @return The {@link IWorldProvider} instance
      * @see IWorldProvider

src/api/java/baritone/api/command/datatypes/ItemById.java

@@ -0,0 +1,51 @@
+/*
+ * 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 <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.command.datatypes;
+
+import baritone.api.command.exception.CommandException;
+import baritone.api.command.helpers.TabCompleteHelper;
+import net.minecraft.item.Item;
+import net.minecraft.util.ResourceLocation;
+
+import java.util.stream.Stream;
+
+/**
+ * @author ZacSharp
+ * written for a yet unmerged #pickUp command
+ */
+public enum ItemById implements IDatatypeFor<Item> {
+    INSTANCE;
+
+    @Override
+    public Item get(IDatatypeContext ctx) throws CommandException {
+        Item item;
+        if ((item = Item.getByNameOrId(ctx.getConsumer().getString())) == null) {
+            throw new IllegalArgumentException("No item found by that id");
+        }
+        return item;
+    }
+
+    @Override
+    public Stream<String> tabComplete(IDatatypeContext ctx) throws CommandException {
+        return new TabCompleteHelper()
+                .append(Item.REGISTRY.getKeys().stream().map(ResourceLocation::toString))
+                .filterPrefixNamespaced(ctx.getConsumer().getString())
+                .sortAlphabetically()
+                .stream();
+    }
+}

src/api/java/baritone/api/process/ICraftingProcess.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 <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.process;
+
+import net.minecraft.item.Item;
+import net.minecraft.item.crafting.IRecipe;
+
+import java.util.List;
+
+/**
+ * Allows you to craft items.
+ */
+public interface ICraftingProcess extends IBaritoneProcess {
+
+    /**
+     * Executes the crafting of the requested recipes such that we obtain the requested amount of output.
+     * It is possible to mix recipes with different out puts, but it may lead to strange results.
+     * @param recipes List of recipes that should be used.
+     * @param amount how many result items are wanted.
+     */
+    void craft(List<IRecipe> recipes, int amount);
+
+    /**
+     * @param item that should be crafted.
+     * @param allCraftingRecipes if all crafting recipes should be returned or only the one that can be crafted
+     * @return List of recipes that result in the provided Item.
+     */
+    List<IRecipe> getCraftingRecipes(Item item, boolean allCraftingRecipes);
+
+    /**
+     * @param recipes that should be crafted.
+     * @param amount how much output is wanted.
+     * @return Can we craft this the requested amount of output from the provided recipes?
+     */
+    boolean canCraft(List<IRecipe> recipes, int amount);
+
+    /**
+     * @param recipe the recipe we want to craft.
+     * @return Do we need a crafting table or can we craft it in our inventory?
+     */
+    boolean canCraftInInventory(IRecipe recipe);
+}

src/main/java/baritone/Baritone.java

@@ -75,6 +75,7 @@ public class Baritone implements IBaritone {
     private final BuilderProcess builderProcess;
     private final ExploreProcess exploreProcess;
     private final FarmProcess farmProcess;
+    private final CraftingProcess craftingProcess;
     private final InventoryPauserProcess inventoryPauserProcess;
 
     private final PathingControlManager pathingControlManager;
@@ -117,6 +118,7 @@ public class Baritone implements IBaritone {
             this.builderProcess          = this.registerProcess(BuilderProcess::new);
             this.exploreProcess          = this.registerProcess(ExploreProcess::new);
             this.farmProcess             = this.registerProcess(FarmProcess::new);
+            this.craftingProcess         = this.registerProcess(CraftingProcess::new);
             this.inventoryPauserProcess  = this.registerProcess(InventoryPauserProcess::new);
             this.registerProcess(BackfillProcess::new);
         }
@@ -162,6 +164,11 @@ public GetToBlockProcess getGetToBlockProcess() {
         return this.getToBlockProcess;
     }
 
+    @Override
+    public CraftingProcess getCraftingProcess() {
+        return this.craftingProcess;
+    }
+
     @Override
     public IPlayerContext getPlayerContext() {
         return this.playerContext;

src/main/java/baritone/command/argparser/DefaultArgParsers.java

@@ -19,6 +19,7 @@
 
 import baritone.api.command.argparser.IArgParser;
 import baritone.api.command.argument.ICommandArgument;
+import net.minecraft.item.Item;
 
 import java.util.Arrays;
 import java.util.List;
@@ -114,11 +115,43 @@ public Boolean parseArg(ICommandArgument arg) throws RuntimeException {
         }
     }
 
+    public static class ItemArgumentParser implements IArgParser.Stateless<Item> {
+        public static final ItemArgumentParser INSTANCE = new ItemArgumentParser();
+
+        @Override
+        public Class<Item> getTarget() {
+            return Item.class;
+        }
+
+        @Override
+        public Item parseArg(ICommandArgument arg) throws Exception {
+            /*
+            String value = arg.getValue();
+            Item item = Item.getByNameOrId(value);
+            if (item == null) {
+                for (IRecipe recipe : CraftingManager.REGISTRY) {
+                    if (recipe.getRecipeOutput().getDisplayName().equalsIgnoreCase(value)) {
+                        return recipe.getRecipeOutput().getItem();
+                    }
+                }
+                throw new IllegalArgumentException("invalid item");
+            } else {
+                return item;
+            }/**/
+            Item item = Item.getByNameOrId(arg.getValue());
+            if (item == null) {
+                throw new IllegalArgumentException("invalid item");
+            }
+            return item;
+        }
+    }
+
     public static final List<IArgParser<?>> ALL = Arrays.asList(
             IntArgumentParser.INSTANCE,
             LongArgumentParser.INSTANCE,
             FloatArgumentParser.INSTANCE,
             DoubleArgumentParser.INSTANCE,
-            BooleanArgumentParser.INSTANCE
+            BooleanArgumentParser.INSTANCE,
+            ItemArgumentParser.INSTANCE
     );
 }

src/main/java/baritone/command/defaults/CraftCommand.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 <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.command.defaults;
+
+import baritone.api.IBaritone;
+import baritone.api.command.Command;
+import baritone.api.command.argument.IArgConsumer;
+import baritone.api.command.datatypes.ItemById;
+import baritone.api.command.exception.CommandException;
+import net.minecraft.item.Item;
+import net.minecraft.item.crafting.CraftingManager;
+import net.minecraft.item.crafting.IRecipe;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Stream;
+
+public class CraftCommand extends Command {
+
+    protected CraftCommand(IBaritone baritone) {
+        super(baritone, "craft");
+    }
+
+    @Override
+    public void execute(String label, IArgConsumer args) throws CommandException {
+        int amount = args.getAsOrDefault(Integer.class, 1);
+        Item item = args.getDatatypeForOrNull(ItemById.INSTANCE);
+        List<IRecipe> recipes;
+
+        if (item != null) {
+            recipes = baritone.getCraftingProcess().getCraftingRecipes(item, false);
+        } else {
+            String itemName = args.rawRest();
+            recipes = new ArrayList<>();
+            for (IRecipe recipe : CraftingManager.REGISTRY) {
+                if (recipe.getRecipeOutput().getDisplayName().equalsIgnoreCase(itemName)) {
+                    recipes.add(recipe);
+                }
+            }
+        }
+
+        if (recipes.isEmpty()) {
+            logDirect("no crafting recipe found.");
+        } else if (!baritone.getCraftingProcess().canCraft(recipes, amount)) {
+            logDirect("Insufficient Resources");
+        } else {
+            baritone.getCraftingProcess().craft(recipes, amount);
+        }
+    }
+
+    @Override
+    public Stream<String> tabComplete(String label, IArgConsumer args) throws CommandException {
+        while (args.has(2)) {
+            if (args.peekDatatypeOrNull(ItemById.INSTANCE) == null) {
+                return Stream.empty();
+            }
+            args.get();
+        }
+        return args.tabCompleteDatatype(ItemById.INSTANCE);
+    }
+
+    @Override
+    public String getShortDesc() {
+        return "Craft a item.";
+    }
+
+    @Override
+    public List<String> getLongDesc() {
+        return Arrays.asList(
+                "Go to a crafting table and craft a item.",
+                "",
+                "Usage:",
+                "> craft [quantity] <item>  - Go to a crafting table, and craft a item.",
+                "Examples:",
+                "> craft 17 planks -> will craft 20 planks out of any logs you have.",
+                "> craft oak wood planks -> will craft 4 oak wood planks."
+        );
+    }
+}

src/main/java/baritone/command/defaults/DefaultCommands.java

@@ -34,6 +34,7 @@ public static List<ICommand> createAll(IBaritone baritone) {
                 new SetCommand(baritone),
                 new CommandAlias(baritone, Arrays.asList("modified", "mod", "baritone", "modifiedsettings"), "List modified settings", "set modified"),
                 new CommandAlias(baritone, "reset", "Reset all settings or just one", "set reset"),
+                new CraftCommand(baritone),
                 new GoalCommand(baritone),
                 new GotoCommand(baritone),
                 new PathCommand(baritone),