Merge branch 'schematic-formats'

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

@@ -20,6 +20,7 @@ package baritone.api;
 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 @@ public interface IBaritoneProvider {
      * @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 class FillSchematic extends AbstractSchematic {
         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 final class BlockOptionalMeta {
         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 final class BlockOptionalMeta {
         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.IBaritone;
 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 final class BaritoneProvider implements IBaritoneProvider {
     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.CommandException;
 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 class BuildCommand extends Command {
     @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;

src/main/java/baritone/process/BuilderProcess.java

@@ -25,7 +25,10 @@ import baritone.api.pathing.goals.GoalGetToBlock;
 import baritone.api.process.IBuilderProcess;
 import baritone.api.process.PathingCommand;
 import baritone.api.process.PathingCommandType;
+import baritone.api.schematic.FillSchematic;
 import baritone.api.schematic.ISchematic;
+import baritone.api.schematic.IStaticSchematic;
+import baritone.api.schematic.format.ISchematicFormat;
 import baritone.api.utils.BetterBlockPos;
 import baritone.api.utils.RayTraceUtils;
 import baritone.api.utils.Rotation;
@@ -37,9 +40,8 @@ import baritone.pathing.movement.MovementHelper;
 import baritone.utils.BaritoneProcessHelper;
 import baritone.utils.BlockStateInterface;
 import baritone.utils.PathingCommandContext;
-import baritone.utils.schematic.FillSchematic;
 import baritone.utils.schematic.MapArtSchematic;
-import baritone.utils.schematic.Schematic;
+import baritone.utils.schematic.SchematicSystem;
 import baritone.utils.schematic.schematica.SchematicaHelper;
 import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
 import net.minecraft.block.BlockAir;
@@ -48,15 +50,12 @@ import net.minecraft.block.state.IBlockState;
 import net.minecraft.init.Blocks;
 import net.minecraft.item.ItemBlock;
 import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.CompressedStreamTools;
-import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.Tuple;
 import net.minecraft.util.math.*;
 
 import java.io.File;
 import java.io.FileInputStream;
-import java.io.IOException;
 import java.util.*;
 
 import static baritone.api.pathing.movement.ActionCosts.COST_INF;
@@ -118,27 +117,38 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
 
     @Override
     public boolean build(String name, File schematic, Vec3i origin) {
-        NBTTagCompound tag;
-        try (FileInputStream fileIn = new FileInputStream(schematic)) {
-            tag = CompressedStreamTools.readCompressed(fileIn);
-        } catch (IOException e) {
+        Optional<ISchematicFormat> format = SchematicSystem.INSTANCE.getByFile(schematic);
+        if (!format.isPresent()) {
+            return false;
+        }
+
+        ISchematic parsed;
+        try {
+            parsed = format.get().parse(new FileInputStream(schematic));
+        } catch (Exception e) {
             e.printStackTrace();
             return false;
         }
-        //noinspection ConstantConditions
-        if (tag == null) {
-            return false;
+
+        if (Baritone.settings().mapArtMode.value) {
+            parsed = new MapArtSchematic((IStaticSchematic) parsed);
         }
-        build(name, parse(tag), origin);
+
+        build(name, parsed, origin);
         return true;
     }
 
     @Override
     public void buildOpenSchematic() {
         if (SchematicaHelper.isSchematicaPresent()) {
-            Optional<Tuple<ISchematic, BlockPos>> schematic = SchematicaHelper.getOpenSchematic();
+            Optional<Tuple<IStaticSchematic, BlockPos>> schematic = SchematicaHelper.getOpenSchematic();
             if (schematic.isPresent()) {
-                this.build(schematic.get().getFirst().toString(), schematic.get().getFirst(), schematic.get().getSecond());
+                IStaticSchematic s = schematic.get().getFirst();
+                this.build(
+                        schematic.get().getFirst().toString(),
+                        Baritone.settings().mapArtMode.value ? new MapArtSchematic(s) : s,
+                        schematic.get().getSecond()
+                );
             } else {
                 logDirect("No schematic currently open");
             }
@@ -160,10 +170,6 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
         return new ArrayList<>(approxPlaceable);
     }
 
-    private static ISchematic parse(NBTTagCompound schematic) {
-        return Baritone.settings().mapArtMode.value ? new MapArtSchematic(schematic) : new Schematic(schematic);
-    }
-
     @Override
     public boolean isActive() {
         return schematic != null;

src/main/java/baritone/utils/schematic/MapArtSchematic.java

@@ -17,24 +17,34 @@
 
 package baritone.utils.schematic;
 
+import baritone.api.schematic.IStaticSchematic;
+import baritone.api.schematic.MaskSchematic;
 import net.minecraft.block.BlockAir;
 import net.minecraft.block.state.IBlockState;
-import net.minecraft.nbt.NBTTagCompound;
 
 import java.util.OptionalInt;
 import java.util.function.Predicate;
 
-public class MapArtSchematic extends Schematic {
+public class MapArtSchematic extends MaskSchematic {
 
     private final int[][] heightMap;
 
-    public MapArtSchematic(NBTTagCompound schematic) {
+    public MapArtSchematic(IStaticSchematic schematic) {
         super(schematic);
-        heightMap = new int[widthX][lengthZ];
+        this.heightMap = generateHeightMap(schematic);
+    }
 
-        for (int x = 0; x < widthX; x++) {
-            for (int z = 0; z < lengthZ; z++) {
-                IBlockState[] column = states[x][z];
+    @Override
+    protected boolean partOfMask(int x, int y, int z, IBlockState currentState) {
+        return y >= this.heightMap[x][z];
+    }
+
+    private static int[][] generateHeightMap(IStaticSchematic schematic) {
+        int[][] heightMap = new int[schematic.widthX()][schematic.lengthZ()];
+
+        for (int x = 0; x < schematic.widthX(); x++) {
+            for (int z = 0; z < schematic.lengthZ(); z++) {
+                IBlockState[] column = schematic.getColumn(x, z);
 
                 OptionalInt lowestBlockY = lastIndexMatching(column, state -> !(state.getBlock() instanceof BlockAir));
                 if (lowestBlockY.isPresent()) {
@@ -44,9 +54,9 @@ public class MapArtSchematic extends Schematic {
                     System.out.println("Letting it be whatever");
                     heightMap[x][z] = 256;
                 }
-
             }
         }
+        return heightMap;
     }
 
     private static <T> OptionalInt lastIndexMatching(T[] arr, Predicate<? super T> predicate) {
@@ -57,10 +67,4 @@ public class MapArtSchematic extends Schematic {
         }
         return OptionalInt.empty();
     }
-
-    @Override
-    public boolean inSchematic(int x, int y, int z, IBlockState currentState) {
-        // in map art, we only care about coordinates in or above the art
-        return super.inSchematic(x, y, z, currentState) && y >= heightMap[x][z];
-    }
 }

src/main/java/baritone/utils/schematic/SchematicSystem.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.utils.schematic;
+
+import baritone.api.command.registry.Registry;
+import baritone.api.schematic.ISchematicSystem;
+import baritone.api.schematic.format.ISchematicFormat;
+import baritone.utils.schematic.format.DefaultSchematicFormats;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.Optional;
+
+/**
+ * @author Brady
+ * @since 12/24/2019
+ */
+public enum SchematicSystem implements ISchematicSystem {
+    INSTANCE;
+
+    private final Registry<ISchematicFormat> registry = new Registry<>();
+
+    SchematicSystem() {
+        Arrays.stream(DefaultSchematicFormats.values()).forEach(this.registry::register);
+    }
+
+    @Override
+    public Registry<ISchematicFormat> getRegistry() {
+        return this.registry;
+    }
+
+    @Override
+    public Optional<ISchematicFormat> getByFile(File file) {
+        return this.registry.stream().filter(format -> format.isFileType(file)).findFirst();
+    }
+}

src/main/java/baritone/utils/schematic/StaticSchematic.java

@@ -17,42 +17,34 @@
 
 package baritone.utils.schematic;
 
-import baritone.api.schematic.ISchematic;
+import baritone.api.schematic.AbstractSchematic;
+import baritone.api.schematic.IStaticSchematic;
 import net.minecraft.block.state.IBlockState;
 
 import java.util.List;
 
-public class FillSchematic implements ISchematic {
+/**
+ * Default implementation of {@link IStaticSchematic}
+ *
+ * @author Brady
+ * @since 12/23/2019
+ */
+public class StaticSchematic extends AbstractSchematic implements IStaticSchematic {
 
-    private final int widthX;
-    private final int heightY;
-    private final int lengthZ;
-    private final IBlockState state;
-
-    public FillSchematic(int widthX, int heightY, int lengthZ, IBlockState state) {
-        this.widthX = widthX;
-        this.heightY = heightY;
-        this.lengthZ = lengthZ;
-        this.state = state;
-    }
+    protected IBlockState[][][] states;
 
     @Override
     public IBlockState desiredState(int x, int y, int z, IBlockState current, List<IBlockState> approxPlaceable) {
-        return state;
+        return this.states[x][z][y];
     }
 
     @Override
-    public int widthX() {
-        return widthX;
+    public IBlockState getDirect(int x, int y, int z) {
+        return this.states[x][z][y];
     }
 
     @Override
-    public int heightY() {
-        return heightY;
-    }
-
-    @Override
-    public int lengthZ() {
-        return lengthZ;
+    public IBlockState[] getColumn(int x, int z) {
+        return this.states[x][z];
     }
 }

src/main/java/baritone/utils/schematic/format/DefaultSchematicFormats.java

@@ -0,0 +1,82 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.utils.schematic.format;
+
+import baritone.api.schematic.IStaticSchematic;
+import baritone.api.schematic.format.ISchematicFormat;
+import baritone.utils.schematic.format.defaults.MCEditSchematic;
+import baritone.utils.schematic.format.defaults.SpongeSchematic;
+import net.minecraft.nbt.CompressedStreamTools;
+import net.minecraft.nbt.NBTTagCompound;
+import org.apache.commons.io.FilenameUtils;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * Default implementations of {@link ISchematicFormat}
+ *
+ * @author Brady
+ * @since 12/13/2019
+ */
+public enum DefaultSchematicFormats implements ISchematicFormat {
+
+    /**
+     * The MCEdit schematic specification. Commonly denoted by the ".schematic" file extension.
+     */
+    MCEDIT("schematic") {
+
+        @Override
+        public IStaticSchematic parse(InputStream input) throws IOException {
+            return new MCEditSchematic(CompressedStreamTools.readCompressed(input));
+        }
+    },
+
+    /**
+     * The SpongePowered Schematic Specification. Commonly denoted by the ".schem" file extension.
+     *
+     * @see <a href="https://github.com/SpongePowered/Schematic-Specification">Sponge Schematic Specification</a>
+     */
+    SPONGE("schem") {
+
+        @Override
+        public IStaticSchematic parse(InputStream input) throws IOException {
+            NBTTagCompound nbt = CompressedStreamTools.readCompressed(input);
+            int version = nbt.getInteger("Version");
+            switch (version) {
+                case 1:
+                case 2:
+                    return new SpongeSchematic(nbt);
+                default:
+                    throw new UnsupportedOperationException("Unsupported Version of a Sponge Schematic");
+            }
+        }
+    };
+
+    private final String extension;
+
+    DefaultSchematicFormats(String extension) {
+        this.extension = extension;
+    }
+
+    @Override
+    public boolean isFileType(File file) {
+        return this.extension.equalsIgnoreCase(FilenameUtils.getExtension(file.getAbsolutePath()));
+    }
+}

src/main/java/baritone/utils/schematic/format/defaults/MCEditSchematic.java

@@ -15,30 +15,27 @@
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.utils.schematic;
+package baritone.utils.schematic.format.defaults;
 
-import baritone.api.schematic.ISchematic;
+import baritone.utils.schematic.StaticSchematic;
 import net.minecraft.block.Block;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.nbt.NBTTagCompound;
 
-import java.util.List;
+/**
+ * @author Brady
+ * @since 12/27/2019
+ */
+public final class MCEditSchematic extends StaticSchematic {
 
-public class Schematic implements ISchematic {
-
-    public final int widthX;
-    public final int heightY;
-    public final int lengthZ;
-    protected final IBlockState[][][] states;
-
-    public Schematic(NBTTagCompound schematic) {
+    public MCEditSchematic(NBTTagCompound schematic) {
         String type = schematic.getString("Materials");
         if (!type.equals("Alpha")) {
             throw new IllegalStateException("bad schematic " + type);
         }
-        widthX = schematic.getInteger("Width");
-        heightY = schematic.getInteger("Height");
-        lengthZ = schematic.getInteger("Length");
+        this.x = schematic.getInteger("Width");
+        this.y = schematic.getInteger("Height");
+        this.z = schematic.getInteger("Length");
         byte[] blocks = schematic.getByteArray("Blocks");
         byte[] metadata = schematic.getByteArray("Data");
 
@@ -51,11 +48,11 @@ public class Schematic implements ISchematic {
                 additional[i * 2 + 1] = (byte) ((addBlocks[i] >> 0) & 0xF); // upper nibble
             }
         }
-        states = new IBlockState[widthX][lengthZ][heightY];
-        for (int y = 0; y < heightY; y++) {
-            for (int z = 0; z < lengthZ; z++) {
-                for (int x = 0; x < widthX; x++) {
-                    int blockInd = (y * lengthZ + z) * widthX + x;
+        this.states = new IBlockState[this.x][this.z][this.y];
+        for (int y = 0; y < this.y; y++) {
+            for (int z = 0; z < this.z; z++) {
+                for (int x = 0; x < this.x; x++) {
+                    int blockInd = (y * this.z + z) * this.x + x;
 
                     int blockID = blocks[blockInd] & 0xFF;
                     if (additional != null) {
@@ -64,29 +61,9 @@ public class Schematic implements ISchematic {
                     }
                     Block block = Block.REGISTRY.getObjectById(blockID);
                     int meta = metadata[blockInd] & 0xFF;
-                    states[x][z][y] = block.getStateFromMeta(meta);
+                    this.states[x][z][y] = block.getStateFromMeta(meta);
                 }
             }
         }
     }
-
-    @Override
-    public IBlockState desiredState(int x, int y, int z, IBlockState current, List<IBlockState> approxPlaceable) {
-        return states[x][z][y];
-    }
-
-    @Override
-    public int widthX() {
-        return widthX;
-    }
-
-    @Override
-    public int heightY() {
-        return heightY;
-    }
-
-    @Override
-    public int lengthZ() {
-        return lengthZ;
-    }
 }

src/main/java/baritone/utils/schematic/format/defaults/SpongeSchematic.java

@@ -0,0 +1,157 @@
+/*
+ * 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.utils.schematic.format.defaults;
+
+import baritone.utils.schematic.StaticSchematic;
+import baritone.utils.type.VarInt;
+import it.unimi.dsi.fastutil.ints.Int2ObjectArrayMap;
+import net.minecraft.block.Block;
+import net.minecraft.block.properties.IProperty;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.ResourceLocation;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * @author Brady
+ * @since 12/27/2019
+ */
+public final class SpongeSchematic extends StaticSchematic {
+
+    public SpongeSchematic(NBTTagCompound nbt) {
+        this.x = nbt.getInteger("Width");
+        this.y = nbt.getInteger("Height");
+        this.z = nbt.getInteger("Length");
+        this.states = new IBlockState[this.x][this.z][this.y];
+
+        Int2ObjectArrayMap<IBlockState> palette = new Int2ObjectArrayMap<>();
+        NBTTagCompound paletteTag = nbt.getCompoundTag("Palette");
+        for (String tag : paletteTag.getKeySet()) {
+            int index = paletteTag.getInteger(tag);
+
+            SerializedBlockState serializedState = SerializedBlockState.getFromString(tag);
+            if (serializedState == null) {
+                throw new IllegalArgumentException("Unable to parse palette tag");
+            }
+
+            IBlockState state = serializedState.deserialize();
+            if (state == null) {
+                throw new IllegalArgumentException("Unable to deserialize palette tag");
+            }
+
+            palette.put(index, state);
+        }
+
+        // BlockData is stored as an NBT byte[], however, the actual data that is represented is a varint[]
+        byte[] rawBlockData = nbt.getByteArray("BlockData");
+        int[] blockData = new int[this.x * this.y * this.z];
+        int offset = 0;
+        for (int i = 0; i < blockData.length; i++) {
+            if (offset >= rawBlockData.length) {
+                throw new IllegalArgumentException("No remaining bytes in BlockData for complete schematic");
+            }
+
+            VarInt varInt = VarInt.read(rawBlockData, offset);
+            blockData[i] = varInt.getValue();
+            offset += varInt.getSize();
+        }
+
+        for (int y = 0; y < this.y; y++) {
+            for (int z = 0; z < this.z; z++) {
+                for (int x = 0; x < this.x; x++) {
+                    int index = (y * this.z + z) * this.x + x;
+                    IBlockState state = palette.get(blockData[index]);
+                    if (state == null) {
+                        throw new IllegalArgumentException("Invalid Palette Index " + index);
+                    }
+
+                    this.states[x][z][y] = state;
+                }
+            }
+        }
+    }
+
+    private static final class SerializedBlockState {
+
+        private static final Pattern REGEX = Pattern.compile("(?<location>(\\w+:)?\\w+)(\\[(?<properties>(\\w+=\\w+,?)+)])?");
+
+        private final ResourceLocation resourceLocation;
+        private final Map<String, String> properties;
+        private IBlockState blockState;
+
+        private SerializedBlockState(ResourceLocation resourceLocation, Map<String, String> properties) {
+            this.resourceLocation = resourceLocation;
+            this.properties = properties;
+        }
+
+        private IBlockState deserialize() {
+            if (this.blockState == null) {
+                Block block = Block.REGISTRY.getObject(this.resourceLocation);
+                this.blockState = block.getDefaultState();
+
+                this.properties.keySet().stream().sorted(String::compareTo).forEachOrdered(key -> {
+                    IProperty<?> property = block.getBlockState().getProperty(key);
+                    if (property != null) {
+                        this.blockState = setPropertyValue(this.blockState, property, this.properties.get(key));
+                    }
+                });
+            }
+            return this.blockState;
+        }
+
+        private static SerializedBlockState getFromString(String s) {
+            Matcher m = REGEX.matcher(s);
+            if (!m.matches()) {
+                return null;
+            }
+
+            try {
+                String location = m.group("location");
+                String properties = m.group("properties");
+
+                ResourceLocation resourceLocation = new ResourceLocation(location);
+                Map<String, String> propertiesMap = new HashMap<>();
+                if (properties != null) {
+                    for (String property : properties.split(",")) {
+                        String[] split = property.split("=");
+                        propertiesMap.put(split[0], split[1]);
+                    }
+                }
+
+                return new SerializedBlockState(resourceLocation, propertiesMap);
+            } catch (Exception e) {
+                e.printStackTrace();
+                return null;
+            }
+        }
+
+        private static <T extends Comparable<T>> IBlockState setPropertyValue(IBlockState state, IProperty<T> property, String value) {
+            Optional<T> parsed = property.parseValue(value).toJavaUtil();
+            if (parsed.isPresent()) {
+                return state.withProperty(property, parsed.get());
+            } else {
+                throw new IllegalArgumentException("Invalid value for property " + property);
+            }
+        }
+    }
+}

src/main/java/baritone/utils/schematic/schematica/SchematicAdapter.java

@@ -17,14 +17,14 @@
 
 package baritone.utils.schematic.schematica;
 
-import baritone.api.schematic.ISchematic;
+import baritone.api.schematic.IStaticSchematic;
 import com.github.lunatrius.schematica.client.world.SchematicWorld;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.util.math.BlockPos;
 
 import java.util.List;
 
-public final class SchematicAdapter implements ISchematic {
+public final class SchematicAdapter implements IStaticSchematic {
 
     private final SchematicWorld schematic;
 
@@ -34,7 +34,12 @@ public final class SchematicAdapter implements ISchematic {
 
     @Override
     public IBlockState desiredState(int x, int y, int z, IBlockState current, List<IBlockState> approxPlaceable) {
-        return schematic.getSchematic().getBlockState(new BlockPos(x, y, z));
+        return this.getDirect(x, y, z);
+    }
+
+    @Override
+    public IBlockState getDirect(int x, int y, int z) {
+        return this.schematic.getSchematic().getBlockState(new BlockPos(x, y, z));
     }
 
     @Override

src/main/java/baritone/utils/schematic/schematica/SchematicaHelper.java

@@ -17,7 +17,7 @@
 
 package baritone.utils.schematic.schematica;
 
-import baritone.api.schematic.ISchematic;
+import baritone.api.schematic.IStaticSchematic;
 import com.github.lunatrius.schematica.Schematica;
 import com.github.lunatrius.schematica.proxy.ClientProxy;
 import net.minecraft.util.Tuple;
@@ -37,7 +37,7 @@ public enum SchematicaHelper {
         }
     }
 
-    public static Optional<Tuple<ISchematic, BlockPos>> getOpenSchematic() {
+    public static Optional<Tuple<IStaticSchematic, BlockPos>> getOpenSchematic() {
         return Optional.ofNullable(ClientProxy.schematic)
                 .map(world -> new Tuple<>(new SchematicAdapter(world), world.position));
     }

src/main/java/baritone/utils/type/VarInt.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.utils.type;
+
+import it.unimi.dsi.fastutil.bytes.ByteArrayList;
+import it.unimi.dsi.fastutil.bytes.ByteList;
+
+/**
+ * @author Brady
+ * @since 12/19/2019
+ */
+public final class VarInt {
+
+    private final int value;
+    private final byte[] serialized;
+    private final int size;
+
+    public VarInt(int value) {
+        this.value = value;
+        this.serialized = serialize0(this.value);
+        this.size = this.serialized.length;
+    }
+
+    /**
+     * @return The integer value that is represented by this {@link VarInt}.
+     */
+    public final int getValue() {
+        return this.value;
+    }
+
+    /**
+     * @return The size of this {@link VarInt}, in bytes, once serialized.
+     */
+    public final int getSize() {
+        return this.size;
+    }
+
+    public final byte[] serialize() {
+        return this.serialized;
+    }
+
+    private static byte[] serialize0(int valueIn) {
+        ByteList bytes = new ByteArrayList();
+
+        int value = valueIn;
+        while ((value & 0x80) != 0) {
+            bytes.add((byte) (value & 0x7F | 0x80));
+            value >>>= 7;
+        }
+        bytes.add((byte) (value & 0xFF));
+
+        return bytes.toByteArray();
+    }
+
+    public static VarInt read(byte[] bytes) {
+        return read(bytes, 0);
+    }
+
+    public static VarInt read(byte[] bytes, int start) {
+        int value = 0;
+        int size = 0;
+        int index = start;
+
+        while (true) {
+            byte b = bytes[index++];
+            value |= (b & 0x7F) << size++ * 7;
+
+            if (size > 5) {
+                throw new IllegalArgumentException("VarInt size cannot exceed 5 bytes");
+            }
+
+            // Most significant bit denotes another byte is to be read.
+            if ((b & 0x80) == 0) {
+                break;
+            }
+        }
+
+        return new VarInt(value);
+    }
+}