Merge branch 'schemType' of SteamWar/SpigotCore into master

SpigotCore_10/src/de/steamwar/sql/Schematic_10.java

@@ -13,11 +13,11 @@ class Schematic_10 {
         return Schematic_8.getPlayerClipboard(player);
     }
 
-    static void setPlayerClipboard(Player player, InputStream is) throws IOException {
+    static void setPlayerClipboard(Player player, InputStream is, boolean schemVersion) throws IOException {
-        Schematic_8.setPlayerClipboard(player, is);
+        Schematic_8.setPlayerClipboard(player, is, schemVersion);
     }
 
-    static Clipboard getClipboard(InputStream is) throws IOException {
+    static Clipboard getClipboard(InputStream is, boolean schemVersion) throws IOException {
-        return Schematic_8.getClipboard(is);
+        return Schematic_8.getClipboard(is, schemVersion);
     }
 }

SpigotCore_12/src/de/steamwar/sql/Schematic_12.java

@@ -32,11 +32,11 @@ class Schematic_12 {
         return outputStream.toByteArray();
     }
 
-    static void setPlayerClipboard(Player player, InputStream is) throws IOException {
+    static void setPlayerClipboard(Player player, InputStream is, boolean schemVersion) throws IOException {
-        Schematic_8.setPlayerClipboard(player, is);
+        Schematic_8.setPlayerClipboard(player, is, schemVersion);
     }
 
-    static Clipboard getClipboard(InputStream is) throws IOException {
+    static Clipboard getClipboard(InputStream is, boolean schemVersion) throws IOException {
-        return Schematic_8.getClipboard(is);
+        return Schematic_8.getClipboard(is, schemVersion);
     }
 }

SpigotCore_8/src/de/steamwar/sql/IDConverter.java

@@ -0,0 +1,43 @@
+package de.steamwar.sql;
+
+import org.bukkit.configuration.file.YamlConfiguration;
+
+import java.io.InputStreamReader;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+class IDConverter {
+    private IDConverter(){}
+
+    static Map<String, BlockTypeID> getMap(){
+        Map<String, BlockTypeID> ids = new HashMap<>();
+        YamlConfiguration legacy = YamlConfiguration.loadConfiguration(new InputStreamReader(Objects.requireNonNull(IDConverter.class.getClassLoader().getResourceAsStream("legacy.yml"))));
+        for(String blockNum : legacy.getKeys(false)){
+            String[] block = blockNum.split(":");
+            String blockString = legacy.getString(blockNum);
+            ids.put(blockString, new BlockTypeID(Integer.parseInt(block[0]), Byte.parseByte(block[1])));
+            if(blockString.contains("["))
+                ids.put(blockString.split("\\[")[0], new BlockTypeID(Integer.parseInt(block[0]), (byte)0));
+        }
+        return ids;
+    }
+
+    static class BlockTypeID{
+        private final int blockId;
+        private final byte dataId;
+
+        private BlockTypeID(int blockId, byte dataId) {
+            this.blockId = blockId;
+            this.dataId = dataId;
+        }
+
+        int getBlockId() {
+            return blockId;
+        }
+
+        byte getDataId() {
+            return dataId;
+        }
+    }
+}

SpigotCore_8/src/de/steamwar/sql/Schematic_8.java

@@ -1,20 +1,34 @@
 package de.steamwar.sql;
 
-import com.sk89q.worldedit.EmptyClipboardException;
+import com.google.common.base.Preconditions;
-import com.sk89q.worldedit.WorldEdit;
+import com.google.common.collect.Maps;
+import com.sk89q.jnbt.*;
+import com.sk89q.worldedit.*;
+import com.sk89q.worldedit.blocks.BaseBlock;
 import com.sk89q.worldedit.bukkit.BukkitWorld;
 import com.sk89q.worldedit.bukkit.WorldEditPlugin;
+import com.sk89q.worldedit.extension.input.ParserContext;
 import com.sk89q.worldedit.extension.platform.Actor;
+import com.sk89q.worldedit.extent.clipboard.BlockArrayClipboard;
 import com.sk89q.worldedit.extent.clipboard.Clipboard;
 import com.sk89q.worldedit.extent.clipboard.io.ClipboardFormat;
+import com.sk89q.worldedit.extent.clipboard.io.ClipboardReader;
+import com.sk89q.worldedit.regions.CuboidRegion;
 import com.sk89q.worldedit.session.ClipboardHolder;
 import com.sk89q.worldedit.world.registry.WorldData;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 
+import javax.annotation.Nullable;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.zip.GZIPInputStream;
 
 class Schematic_8 {
     private Schematic_8(){}
@@ -36,19 +50,213 @@ class Schematic_8 {
         return outputStream.toByteArray();
     }
 
-    static void setPlayerClipboard(Player player, InputStream is) throws IOException {
+    static void setPlayerClipboard(Player player, InputStream is, boolean schemFormat) throws IOException {
         WorldData world = new BukkitWorld(player.getWorld()).getWorldData();
-        Clipboard clipboard = getClipboard(is);
+        Clipboard clipboard = getClipboard(is, schemFormat);
 
         Actor actor = getWorldEditPlugin().wrapCommandSender(player);
         getWorldEditPlugin().getWorldEdit().getSessionManager().get(actor).setClipboard(new ClipboardHolder(clipboard, world));
     }
 
-    static Clipboard getClipboard(InputStream is) throws IOException {
+    static Clipboard getClipboard(InputStream is, boolean schemFormat) throws IOException {
+        if(schemFormat)
+            return new SpongeSchematicReader(new NBTInputStream(new GZIPInputStream(is))).read(WorldEdit.getInstance().getServer().getWorlds().get(0).getWorldData());
+        else
             return ClipboardFormat.SCHEMATIC.getReader(is).read(WorldEdit.getInstance().getServer().getWorlds().get(0).getWorldData());
     }
 
     private static WorldEditPlugin getWorldEditPlugin() {
         return (WorldEditPlugin) Bukkit.getPluginManager().getPlugin("WorldEdit");
     }
+
+    public static class SpongeSchematicReader implements ClipboardReader {
+
+        private final NBTInputStream inputStream;
+        private int schematicVersion = -1;
+
+        SpongeSchematicReader(NBTInputStream inputStream) {
+            Preconditions.checkNotNull(inputStream);
+            this.inputStream = inputStream;
+        }
+
+        @Override
+        public Clipboard read(WorldData worldData) throws IOException {
+            CompoundTag schematicTag = this.getBaseTag();
+            if (this.schematicVersion == 1) {
+                return this.readSchematic(schematicTag);
+            } else if (this.schematicVersion == 2) {
+                return this.readSchematic(schematicTag);
+            } else {
+                throw new IOException("This schematic version is currently not supported");
+            }
+        }
+
+        private CompoundTag getBaseTag() throws IOException {
+            NamedTag rootTag = this.inputStream.readNamedTag();
+            if (!rootTag.getName().equals("Schematic")) {
+                throw new IOException("Tag 'Schematic' does not exist or is not first");
+            } else {
+                CompoundTag schematicTag = (CompoundTag)rootTag.getTag();
+                Map<String, Tag> schematic = schematicTag.getValue();
+                this.schematicVersion = (requireTag(schematic, "Version", IntTag.class)).getValue();
+                return schematicTag;
+            }
+        }
+
+        private BlockArrayClipboard readSchematic(CompoundTag schematicTag) throws IOException {
+            final Map<String, IDConverter.BlockTypeID> ids = IDConverter.getMap();
+
+            Map<String, Tag> schematic = schematicTag.getValue();
+            int width = (requireTag(schematic, "Width", ShortTag.class)).getValue();
+            int height = (requireTag(schematic, "Height", ShortTag.class)).getValue();
+            int length = (requireTag(schematic, "Length", ShortTag.class)).getValue();
+            IntArrayTag offsetTag = getTag(schematic, "Offset", IntArrayTag.class);
+            int[] offsetParts;
+            if (offsetTag != null) {
+                offsetParts = offsetTag.getValue();
+                if (offsetParts.length != 3)
+                    throw new IOException("Invalid offset specified in schematic.");
+            } else {
+                offsetParts = new int[]{0, 0, 0};
+            }
+
+            BlockVector min = new BlockVector(offsetParts[0], offsetParts[1], offsetParts[2]);
+            CompoundTag metadataTag = getTag(schematic, "Metadata", CompoundTag.class);
+            Vector origin;
+            CuboidRegion region;
+            if (metadataTag != null && metadataTag.containsKey("WEOffsetX")) {
+                Map<String, Tag> metadata = metadataTag.getValue();
+                int offsetX = (requireTag(metadata, "WEOffsetX", IntTag.class)).getValue();
+                int offsetY = (requireTag(metadata, "WEOffsetY", IntTag.class)).getValue();
+                int offsetZ = (requireTag(metadata, "WEOffsetZ", IntTag.class)).getValue();
+                BlockVector offset = new BlockVector(offsetX, offsetY, offsetZ);
+                origin = min.subtract(offset);
+                region = new CuboidRegion(min, min.add(width, height, length).subtract(BlockVector.ONE));
+            } else {
+                origin = min;
+                region = new CuboidRegion(min, min.add(width, height, length).subtract(BlockVector.ONE));
+            }
+
+            IntTag paletteMaxTag = getTag(schematic, "PaletteMax", IntTag.class);
+            Map<String, Tag> paletteObject = requireTag(schematic, "Palette", CompoundTag.class).getValue();
+            if (paletteMaxTag != null && paletteObject.size() != paletteMaxTag.getValue())
+                throw new IOException("Block palette size does not match expected size.");
+
+            Map<Integer, BaseBlock> palette = new HashMap<>();
+            ParserContext parserContext = new ParserContext();
+            parserContext.setRestricted(false);
+            parserContext.setPreferringWildcard(false);
+
+            int id;
+            BaseBlock state;
+            for(Iterator iterator = paletteObject.keySet().iterator(); iterator.hasNext(); palette.put(id, state)) {
+                String palettePart = (String)iterator.next();
+                id = requireTag(paletteObject, palettePart, IntTag.class).getValue();
+
+                IDConverter.BlockTypeID blockID = ids.get(palettePart);
+                if(blockID == null){
+                    blockID = ids.get(palettePart.split("\\[")[0]);
+                }
+
+                if(blockID == null){
+                    state = new BaseBlock(0); //AIR
+                }else{
+                    state = new BaseBlock(blockID.getBlockId(), blockID.getDataId());
+                }
+            }
+
+            byte[] blocks = requireTag(schematic, "BlockData", ByteArrayTag.class).getValue();
+            Map<BlockVector, Map<String, Tag>> tileEntitiesMap = new HashMap<>();
+            ListTag tileEntities = getTag(schematic, "BlockEntities", ListTag.class);
+            if (tileEntities == null) {
+                tileEntities = getTag(schematic, "TileEntities", ListTag.class);
+            }
+
+            if (tileEntities != null) {
+                List<Map<String, Tag>> tileEntityTags = tileEntities.getValue().stream().map((tag) ->
+                        (CompoundTag)tag
+                ).map(CompoundTag::getValue).collect(Collectors.toList());
+
+                BlockVector pt;
+                Map<String, Tag> tileEntity;
+                for(Iterator<Map<String, Tag>> var20 = tileEntityTags.iterator(); var20.hasNext(); tileEntitiesMap.put(pt, tileEntity)) {
+                    tileEntity = var20.next();
+                    int[] pos = requireTag(tileEntity, "Pos", IntArrayTag.class).getValue();
+                    pt = new BlockVector(pos[0], pos[1], pos[2]);
+                    Map<String, Tag> values = Maps.newHashMap(tileEntity);
+                    values.put("x", new IntTag(pt.getBlockX()));
+                    values.put("y", new IntTag(pt.getBlockY()));
+                    values.put("z", new IntTag(pt.getBlockZ()));
+                    values.put("id", values.get("Id"));
+                    values.remove("Id");
+                    values.remove("Pos");
+                    tileEntity = values;
+                }
+            }
+
+            BlockArrayClipboard clipboard = new BlockArrayClipboard(region);
+            clipboard.setOrigin(origin);
+            int index = 0;
+
+            for(int i = 0; i < blocks.length; ++index) {
+                int value = 0;
+                int varintLength = 0;
+
+                while(true) {
+                    value |= (blocks[i] & 127) << varintLength++ * 7;
+                    if (varintLength > 5) {
+                        throw new IOException("VarInt too big (probably corrupted data)");
+                    }
+
+                    if ((blocks[i] & 128) != 128) {
+                        ++i;
+                        int y = index / (width * length);
+                        int z = index % (width * length) / width;
+                        int x = index % (width * length) % width;
+                        BaseBlock block = palette.get(value);
+                        BlockVector pt = new BlockVector(x, y, z);
+
+                        try {
+                            if (tileEntitiesMap.containsKey(pt)) {
+                                block.setNbtData(new CompoundTag(tileEntitiesMap.get(pt)));
+                                clipboard.setBlock(clipboard.getMinimumPoint().add(pt), block);
+                            } else {
+                                clipboard.setBlock(clipboard.getMinimumPoint().add(pt), block);
+                            }
+                            break;
+                        } catch (WorldEditException var30) {
+                            throw new IOException("Failed to load a block in the schematic");
+                        }
+                    }
+
+                    ++i;
+                }
+            }
+
+            return clipboard;
+        }
+
+        private static <T extends Tag> T requireTag(Map<String, Tag> items, String key, Class<T> expected) throws IOException {
+            if (!items.containsKey(key)) {
+                throw new IOException("Schematic file is missing a \"" + key + "\" tag");
+            } else {
+                Tag tag = items.get(key);
+                if (!expected.isInstance(tag)) {
+                    throw new IOException(key + " tag is not of tag type " + expected.getName());
+                } else {
+                    return expected.cast(tag);
+                }
+            }
+        }
+
+        @Nullable
+        private static <T extends Tag> T getTag(Map<String, Tag> items, String key, Class<T> expected) {
+            if (!items.containsKey(key)) {
+                return null;
+            } else {
+                Tag test = items.get(key);
+                return !expected.isInstance(test) ? null : expected.cast(test);
+            }
+        }
+    }
 }

SpigotCore_9/src/de/steamwar/sql/Schematic_9.java

@@ -13,11 +13,11 @@ class Schematic_9 {
         return Schematic_8.getPlayerClipboard(player);
     }
 
-    static void setPlayerClipboard(Player player, InputStream is) throws IOException {
+    static void setPlayerClipboard(Player player, InputStream is, boolean schemVersion) throws IOException {
-        Schematic_8.setPlayerClipboard(player, is);
+        Schematic_8.setPlayerClipboard(player, is, schemVersion);
     }
 
-    static Clipboard getClipboard(InputStream is) throws IOException {
+    static Clipboard getClipboard(InputStream is, boolean schemVersion) throws IOException {
-        return Schematic_8.getClipboard(is);
+        return Schematic_8.getClipboard(is, schemVersion);
     }
 }

SpigotCore_Main/src/de/steamwar/sql/Schematic.java

@@ -142,13 +142,10 @@ public class Schematic {
 	}
 
 	public boolean availible(){
-		return Core.getVersion() > 12 || !schemFormat;
+		return true;
 	}
 
-	public Clipboard load() throws WrongVersionException, IOException, NoClipboardException {
+	public Clipboard load() throws IOException, NoClipboardException {
-		if(Core.getVersion() <= 12 && schemFormat)
-			throw new WrongVersionException();
-
 		ResultSet rs = SQL.select("SELECT SchemData FROM Schematic WHERE SchemID = ?", schemID);
 		try {
 			rs.next();
@@ -158,26 +155,24 @@ public class Schematic {
 			InputStream is = schemData.getBinaryStream();
 			switch(Core.getVersion()){
 				case 8:
-					return Schematic_8.getClipboard(is);
+					return Schematic_8.getClipboard(is, schemFormat);
 				case 9:
-					return Schematic_9.getClipboard(is);
+					return Schematic_9.getClipboard(is, schemFormat);
 				case 10:
-					return Schematic_10.getClipboard(is);
+					return Schematic_10.getClipboard(is, schemFormat);
 				case 14:
 					return Schematic_14.getClipboard(is, schemFormat);
 				case 15:
 					return Schematic_15.getClipboard(is, schemFormat);
 				default:
-					return Schematic_12.getClipboard(is);
+					return Schematic_12.getClipboard(is, schemFormat);
 			}
 		} catch (SQLException e) {
 			throw new IOException(e);
 		}
 	}
 
-	public void loadToPlayer(Player player) throws IOException, NoClipboardException, WrongVersionException {
+	public void loadToPlayer(Player player) throws IOException, NoClipboardException {
-		if(Core.getVersion() <= 12 && schemFormat)
-			throw new WrongVersionException();
 
 		ResultSet rs = SQL.select("SELECT SchemData FROM Schematic WHERE SchemID = ?", schemID);
 		try {
@@ -188,13 +183,13 @@ public class Schematic {
 			InputStream is = blob.getBinaryStream();
 			switch(Core.getVersion()){
 				case 8:
-					Schematic_8.setPlayerClipboard(player, is);
+					Schematic_8.setPlayerClipboard(player, is, schemFormat);
 					break;
 				case 9:
-					Schematic_9.setPlayerClipboard(player, is);
+					Schematic_9.setPlayerClipboard(player, is, schemFormat);
 					break;
 				case 10:
-					Schematic_10.setPlayerClipboard(player, is);
+					Schematic_10.setPlayerClipboard(player, is, schemFormat);
 					break;
 				case 14:
 					Schematic_14.setPlayerClipboard(player, is, schemFormat);
@@ -203,7 +198,7 @@ public class Schematic {
 					Schematic_15.setPlayerClipboard(player, is, schemFormat);
 					break;
 				default:
-					Schematic_12.setPlayerClipboard(player, is);
+					Schematic_12.setPlayerClipboard(player, is, schemFormat);
 			}
 		} catch (SQLException e) {
 			throw new IOException(e);