Merge branch 'schematic-formats'

Author: ZeroMemes

src/api/java/baritone/api/IBaritoneProvider.java

@@ -20,6 +20,7 @@
 import baritone.api.cache.IWorldScanner;
 import baritone.api.command.ICommand;
 import baritone.api.command.ICommandSystem;
+import baritone.api.schematic.ISchematicSystem;
 import net.minecraft.client.entity.EntityPlayerSP;
 
 import java.util.List;
@@ -82,4 +83,9 @@ default IBaritone getBaritoneForPlayer(EntityPlayerSP player) {
      * @return The {@link ICommandSystem} instance.
      */
     ICommandSystem getCommandSystem();
+
+    /**
+     * @return The {@link ISchematicSystem} instance.
+     */
+    ISchematicSystem getSchematicSystem();
 }

src/api/java/baritone/api/Settings.java

@@ -811,6 +811,12 @@ public final class Settings {
      */
     public final Setting<Boolean> schematicOrientationZ = new Setting<>(false);
 
+    /**
+     * The fallback used by the build command when no extension is specified. This may be useful if schematics of a
+     * particular format are used often, and the user does not wish to have to specify the extension with every usage.
+     */
+    public final Setting<String> schematicFallbackExtension = new Setting<>("schematic");
+
     /**
      * 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.

src/api/java/baritone/api/schematic/AbstractSchematic.java

@@ -23,6 +23,10 @@ public abstract class AbstractSchematic implements ISchematic {
     protected int y;
     protected int z;
 
+    public AbstractSchematic() {
+        this(0, 0, 0);
+    }
+
     public AbstractSchematic(int x, int y, int z) {
         this.x = x;
         this.y = y;

src/api/java/baritone/api/schematic/FillSchematic.java

@@ -32,6 +32,10 @@ public FillSchematic(int x, int y, int z, BlockOptionalMeta bom) {
         this.bom = bom;
     }
 
+    public FillSchematic(int x, int y, int z, IBlockState state) {
+        this(x, y, z, new BlockOptionalMeta(state.getBlock(), state.getBlock().getMetaFromState(state)));
+    }
+
     public BlockOptionalMeta getBom() {
         return bom;
     }

src/api/java/baritone/api/schematic/ISchematicSystem.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 <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.schematic;
+
+import baritone.api.command.registry.Registry;
+import baritone.api.schematic.format.ISchematicFormat;
+
+import java.io.File;
+import java.util.Optional;
+
+/**
+ * @author Brady
+ * @since 12/23/2019
+ */
+public interface ISchematicSystem {
+
+    /**
+     * @return The registry of supported schematic formats
+     */
+    Registry<ISchematicFormat> getRegistry();
+
+    /**
+     * Attempts to find an {@link ISchematicFormat} that supports the specified schematic file.
+     *
+     * @param file A schematic file
+     * @return The corresponding format for the file, {@link Optional#empty()} if no candidates were found.
+     */
+    Optional<ISchematicFormat> getByFile(File file);
+}

src/api/java/baritone/api/schematic/IStaticSchematic.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 <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.schematic;
+
+import net.minecraft.block.state.IBlockState;
+
+/**
+ * A static schematic is capable of providing the desired state at a given position without
+ * additional context. Schematics of this type are expected to have non-varying contents.
+ * 
+ * @see #getDirect(int, int, int) 
+ *
+ * @author Brady
+ * @since 12/24/2019
+ */
+public interface IStaticSchematic extends ISchematic {
+
+    /**
+     * Gets the {@link IBlockState} for a given position in this schematic. It should be guaranteed
+     * that the return value of this method will not change given that the parameters are the same.
+     *
+     * @param x The X block position
+     * @param y The Y block position
+     * @param z The Z block position
+     * @return The desired state at the specified position.
+     */
+    IBlockState getDirect(int x, int y, int z);
+
+    /**
+     * Returns an {@link IBlockState} array of size {@link #heightY()} which contains all
+     * desired block states in the specified vertical column. The index of {@link IBlockState}s
+     * in the array are equivalent to their Y position in the schematic.
+     *
+     * @param x The X column position
+     * @param z The Z column position
+     * @return An {@link IBlockState} array
+     */
+    default IBlockState[] getColumn(int x, int z) {
+        IBlockState[] column = new IBlockState[this.heightY()];
+        for (int i = 0; i < this.heightY(); i++) {
+            column[i] = getDirect(x, i, z);
+        }
+        return column;
+    }
+}

src/api/java/baritone/api/schematic/format/ISchematicFormat.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 <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.schematic.format;
+
+import baritone.api.schematic.ISchematic;
+import baritone.api.schematic.IStaticSchematic;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * The base of a {@link ISchematic} file format
+ *
+ * @author Brady
+ * @since 12/23/2019
+ */
+public interface ISchematicFormat {
+
+    /**
+     * @return The parser for creating schematics of this format
+     */
+    IStaticSchematic parse(InputStream input) throws IOException;
+
+    /**
+     * @param file The file to check against
+     * @return Whether or not the specified file matches this schematic format
+     */
+    boolean isFileType(File file);
+}

src/api/java/baritone/api/utils/BlockOptionalMeta.java

@@ -178,16 +178,27 @@ public BlockOptionalMeta(@Nonnull String selector) {
         normalizations = Collections.unmodifiableMap(_normalizations);
     }
 
-    private static <C extends Comparable<C>, P extends IProperty<C>> P castToIProperty(Object value) {
+    public static <C extends Comparable<C>, P extends IProperty<C>> P castToIProperty(Object value) {
         //noinspection unchecked
         return (P) value;
     }
 
-    private static <C extends Comparable<C>, P extends IProperty<C>> C castToIPropertyValue(P iproperty, Object value) {
+    public static <C extends Comparable<C>, P extends IProperty<C>> C castToIPropertyValue(P iproperty, Object value) {
         //noinspection unchecked
         return (C) value;
     }
 
+    /**
+     * Normalizes the specified blockstate by setting meta-affecting properties which
+     * are not being targeted by the meta parameter to their default values.
+     * <p>
+     * For example, block variant/color is the primary target for the meta value, so properties
+     * such as rotation/facing direction will be set to default values in order to nullify
+     * the effect that they have on the state's meta value.
+     *
+     * @param state The state to normalize
+     * @return The normalized block state
+     */
     public static IBlockState normalize(IBlockState state) {
         IBlockState newState = state;
 
@@ -220,6 +231,15 @@ public static IBlockState normalize(IBlockState state) {
         return newState;
     }
 
+    /**
+     * Evaluate the target meta value for the specified state. The target meta value is
+     * most often that which is influenced by the variant/color property of the block state.
+     * 
+     * @see #normalize(IBlockState) 
+     * 
+     * @param state The state to check
+     * @return The target meta of the state
+     */
     public static int stateMeta(IBlockState state) {
         return state.getBlock().getMetaFromState(normalize(state));
     }

src/main/java/baritone/BaritoneProvider.java

@@ -21,9 +21,11 @@
 import baritone.api.IBaritoneProvider;
 import baritone.api.cache.IWorldScanner;
 import baritone.api.command.ICommandSystem;
+import baritone.api.schematic.ISchematicSystem;
 import baritone.command.BaritoneChatControl;
 import baritone.cache.WorldScanner;
 import baritone.command.CommandSystem;
+import baritone.utils.schematic.SchematicSystem;
 
 import java.util.Collections;
 import java.util.List;
@@ -64,4 +66,9 @@ public IWorldScanner getWorldScanner() {
     public ICommandSystem getCommandSystem() {
         return CommandSystem.INSTANCE;
     }
+
+    @Override
+    public ISchematicSystem getSchematicSystem() {
+        return SchematicSystem.INSTANCE;
+    }
 }

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

@@ -17,6 +17,7 @@
 
 package baritone.command.defaults;
 
+import baritone.Baritone;
 import baritone.api.IBaritone;
 import baritone.api.utils.BetterBlockPos;
 import baritone.api.command.Command;
@@ -26,11 +27,11 @@
 import baritone.api.command.exception.CommandInvalidStateException;
 import baritone.api.command.argument.IArgConsumer;
 import net.minecraft.client.Minecraft;
+import org.apache.commons.io.FilenameUtils;
 
 import java.io.File;
 import java.util.Arrays;
 import java.util.List;
-import java.util.Locale;
 import java.util.stream.Stream;
 
 public class BuildCommand extends Command {
@@ -44,8 +45,8 @@ public BuildCommand(IBaritone baritone) {
     @Override
     public void execute(String label, IArgConsumer args) throws CommandException {
         File file = args.getDatatypePost(RelativeFile.INSTANCE, schematicsDir).getAbsoluteFile();
-        if (!file.getName().toLowerCase(Locale.US).endsWith(".schematic")) {
-            file = new File(file.getAbsolutePath() + ".schematic");
+        if (FilenameUtils.getExtension(file.getAbsolutePath()).isEmpty()) {
+            file = new File(file.getAbsolutePath() + "." + Baritone.settings().schematicFallbackExtension);
         }
         BetterBlockPos origin = ctx.playerFeet();
         BetterBlockPos buildOrigin;