Current progress with update

worldedit-core/src/main/java/com/sk89q/worldedit/extent/clipboard/io/MCEditSchematicReader.java

@@ -0,0 +1,316 @@
+/*
+ * WorldEdit, a Minecraft world manipulation toolkit
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) WorldEdit team and contributors
+ *
+ * This program 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.
+ *
+ * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.sk89q.worldedit.extent.clipboard.io;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.sk89q.jnbt.ByteArrayTag;
+import com.sk89q.jnbt.CompoundTag;
+import com.sk89q.jnbt.IntTag;
+import com.sk89q.jnbt.ListTag;
+import com.sk89q.jnbt.NBTInputStream;
+import com.sk89q.jnbt.NamedTag;
+import com.sk89q.jnbt.ShortTag;
+import com.sk89q.jnbt.StringTag;
+import com.sk89q.jnbt.Tag;
+import com.sk89q.worldedit.WorldEditException;
+import com.sk89q.worldedit.entity.BaseEntity;
+import com.sk89q.worldedit.extent.clipboard.BlockArrayClipboard;
+import com.sk89q.worldedit.extent.clipboard.Clipboard;
+import com.sk89q.worldedit.extent.clipboard.io.legacycompat.NBTCompatibilityHandler;
+import com.sk89q.worldedit.extent.clipboard.io.legacycompat.SignCompatibilityHandler;
+import com.sk89q.worldedit.math.BlockVector3;
+import com.sk89q.worldedit.regions.CuboidRegion;
+import com.sk89q.worldedit.regions.Region;
+import com.sk89q.worldedit.util.Location;
+import com.sk89q.worldedit.world.block.BlockState;
+import com.sk89q.worldedit.world.entity.EntityType;
+import com.sk89q.worldedit.world.entity.EntityTypes;
+import com.sk89q.worldedit.world.registry.LegacyMapper;
+import com.sk89q.worldedit.world.storage.NBTConversions;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Reads schematic files that are compatible with MCEdit and other editors.
+ */
+public class MCEditSchematicReader extends NBTSchematicReader {
+
+    private static final List<NBTCompatibilityHandler> COMPATIBILITY_HANDLERS = new ArrayList<>();
+
+    static {
+        COMPATIBILITY_HANDLERS.add(new SignCompatibilityHandler());
+        // TODO Add a handler for skulls, flower pots, note blocks, etc.
+    }
+
+    private static final Logger log = Logger.getLogger(MCEditSchematicReader.class.getCanonicalName());
+    private final NBTInputStream inputStream;
+
+    /**
+     * Create a new instance.
+     *
+     * @param inputStream the input stream to read from
+     */
+    public MCEditSchematicReader(NBTInputStream inputStream) {
+        checkNotNull(inputStream);
+        this.inputStream = inputStream;
+    }
+
+    @Override
+    public Clipboard read() throws IOException {
+        // Schematic tag
+        NamedTag rootTag = inputStream.readNamedTag();
+        if (!rootTag.getName().equals("Schematic")) {
+            throw new IOException("Tag 'Schematic' does not exist or is not first");
+        }
+        CompoundTag schematicTag = (CompoundTag) rootTag.getTag();
+
+        // Check
+        Map<String, Tag> schematic = schematicTag.getValue();
+        if (!schematic.containsKey("Blocks")) {
+            throw new IOException("Schematic file is missing a 'Blocks' tag");
+        }
+
+        // Check type of Schematic
+        String materials = requireTag(schematic, "Materials", StringTag.class).getValue();
+        if (!materials.equals("Alpha")) {
+            throw new IOException("Schematic file is not an Alpha schematic");
+        }
+
+        // ====================================================================
+        // Metadata
+        // ====================================================================
+
+        BlockVector3 origin;
+        Region region;
+
+        // Get information
+        short width = requireTag(schematic, "Width", ShortTag.class).getValue();
+        short height = requireTag(schematic, "Height", ShortTag.class).getValue();
+        short length = requireTag(schematic, "Length", ShortTag.class).getValue();
+
+        try {
+            int originX = requireTag(schematic, "WEOriginX", IntTag.class).getValue();
+            int originY = requireTag(schematic, "WEOriginY", IntTag.class).getValue();
+            int originZ = requireTag(schematic, "WEOriginZ", IntTag.class).getValue();
+            BlockVector3 min = new BlockVector3(originX, originY, originZ);
+
+            int offsetX = requireTag(schematic, "WEOffsetX", IntTag.class).getValue();
+            int offsetY = requireTag(schematic, "WEOffsetY", IntTag.class).getValue();
+            int offsetZ = requireTag(schematic, "WEOffsetZ", IntTag.class).getValue();
+            BlockVector3 offset = new BlockVector3(offsetX, offsetY, offsetZ);
+
+            origin = min.subtract(offset);
+            region = new CuboidRegion(min, min.add(width, height, length).subtract(BlockVector3.ONE));
+        } catch (IOException ignored) {
+            origin = BlockVector3.ZERO;
+            region = new CuboidRegion(origin, origin.add(width, height, length).subtract(BlockVector3.ONE));
+        }
+
+        // ====================================================================
+        // Blocks
+        // ====================================================================
+
+        // Get blocks
+        byte[] blockId = requireTag(schematic, "Blocks", ByteArrayTag.class).getValue();
+        byte[] blockData = requireTag(schematic, "Data", ByteArrayTag.class).getValue();
+        byte[] addId = new byte[0];
+        short[] blocks = new short[blockId.length]; // Have to later combine IDs
+
+        // We support 4096 block IDs using the same method as vanilla Minecraft, where
+        // the highest 4 bits are stored in a separate byte array.
+        if (schematic.containsKey("AddBlocks")) {
+            addId = requireTag(schematic, "AddBlocks", ByteArrayTag.class).getValue();
+        }
+
+        // Combine the AddBlocks data with the first 8-bit block ID
+        for (int index = 0; index < blockId.length; index++) {
+            if ((index >> 1) >= addId.length) { // No corresponding AddBlocks index
+                blocks[index] = (short) (blockId[index] & 0xFF);
+            } else {
+                if ((index & 1) == 0) {
+                    blocks[index] = (short) (((addId[index >> 1] & 0x0F) << 8) + (blockId[index] & 0xFF));
+                } else {
+                    blocks[index] = (short) (((addId[index >> 1] & 0xF0) << 4) + (blockId[index] & 0xFF));
+                }
+            }
+        }
+
+        // Need to pull out tile entities
+        List<Tag> tileEntities = requireTag(schematic, "TileEntities", ListTag.class).getValue();
+        Map<BlockVector3, Map<String, Tag>> tileEntitiesMap = new HashMap<>();
+
+        for (Tag tag : tileEntities) {
+            if (!(tag instanceof CompoundTag)) continue;
+            CompoundTag t = (CompoundTag) tag;
+
+            int x = 0;
+            int y = 0;
+            int z = 0;
+
+            Map<String, Tag> values = new HashMap<>();
+
+            for (Map.Entry<String, Tag> entry : t.getValue().entrySet()) {
+                switch (entry.getKey()) {
+                    case "x":
+                        if (entry.getValue() instanceof IntTag) {
+                            x = ((IntTag) entry.getValue()).getValue();
+                        }
+                        break;
+                    case "y":
+                        if (entry.getValue() instanceof IntTag) {
+                            y = ((IntTag) entry.getValue()).getValue();
+                        }
+                        break;
+                    case "z":
+                        if (entry.getValue() instanceof IntTag) {
+                            z = ((IntTag) entry.getValue()).getValue();
+                        }
+                        break;
+                }
+
+                values.put(entry.getKey(), entry.getValue());
+            }
+
+            int index = y * width * length + z * width + x;
+            BlockState block = LegacyMapper.getInstance().getBlockFromLegacy(blocks[index], blockData[index]);
+            if (block != null) {
+                for (NBTCompatibilityHandler handler : COMPATIBILITY_HANDLERS) {
+                    if (handler.isAffectedBlock(block)) {
+                        handler.updateNBT(block, values);
+                    }
+                }
+            }
+
+            BlockVector3 vec = new BlockVector3(x, y, z);
+            tileEntitiesMap.put(vec, values);
+        }
+
+        BlockArrayClipboard clipboard = new BlockArrayClipboard(region);
+        clipboard.setOrigin(origin);
+
+        // Don't log a torrent of errors
+        int failedBlockSets = 0;
+
+        for (int x = 0; x < width; ++x) {
+            for (int y = 0; y < height; ++y) {
+                for (int z = 0; z < length; ++z) {
+                    int index = y * width * length + z * width + x;
+                    BlockVector3 pt = new BlockVector3(x, y, z);
+                    BlockState state = LegacyMapper.getInstance().getBlockFromLegacy(blocks[index], blockData[index]);
+
+                    try {
+                        if (state != null) {
+                            if (tileEntitiesMap.containsKey(pt)) {
+                                clipboard.setBlock(region.getMinimumPoint().add(pt), state.toBaseBlock(new CompoundTag(tileEntitiesMap.get(pt))));
+                            } else {
+                                clipboard.setBlock(region.getMinimumPoint().add(pt), state);
+                            }
+                        } else {
+                            log.warning("Unknown block when pasting schematic: " + blocks[index] + ":" + blockData[index] + ". Please report this issue.");
+                        }
+                    } catch (WorldEditException e) {
+                        switch (failedBlockSets) {
+                            case 0:
+                                log.log(Level.WARNING, "Failed to set block on a Clipboard", e);
+                                break;
+                            case 1:
+                                log.log(Level.WARNING, "Failed to set block on a Clipboard (again) -- no more messages will be logged", e);
+                                break;
+                            default:
+                        }
+
+                        failedBlockSets++;
+                    }
+                }
+            }
+        }
+
+        // ====================================================================
+        // Entities
+        // ====================================================================
+
+        try {
+            List<Tag> entityTags = requireTag(schematic, "Entities", ListTag.class).getValue();
+
+            for (Tag tag : entityTags) {
+                if (tag instanceof CompoundTag) {
+                    CompoundTag compound = (CompoundTag) tag;
+                    String id = convertEntityId(compound.getString("id"));
+                    Location location = NBTConversions.toLocation(clipboard, compound.getListTag("Pos"), compound.getListTag("Rotation"));
+
+                    if (!id.isEmpty()) {
+                        EntityType entityType = EntityTypes.get(id.toLowerCase());
+                        if (entityType != null) {
+                            BaseEntity state = new BaseEntity(entityType, compound);
+                            clipboard.createEntity(location, state);
+                        } else {
+                            log.warning("Unknown entity when pasting schematic: " + id.toLowerCase());
+                        }
+                    }
+                }
+            }
+        } catch (IOException ignored) { // No entities? No problem
+        }
+
+        return clipboard;
+    }
+
+    private String convertEntityId(String id) {
+        switch(id) {
+            case "xp_orb":
+                return "experience_orb";
+            case "xp_bottle":
+                return "experience_bottle";
+            case "eye_of_ender_signal":
+                return "eye_of_ender";
+            case "ender_crystal":
+                return "end_crystal";
+            case "fireworks_rocket":
+                return "firework_rocket";
+            case "commandblock_minecart":
+                return "command_block_minecart";
+            case "snowman":
+                return "snow_golem";
+            case "villager_golem":
+                return "iron_golem";
+            case "evocation_fangs":
+                return "evoker_fangs";
+            case "evocation_illager":
+                return "evoker";
+            case "vindication_illager":
+                return "vindicator";
+            case "illusion_illager":
+                return "illusioner";
+        }
+        return id;
+    }
+
+    @Override
+    public void close() throws IOException {
+        inputStream.close();
+    }
+}

worldedit-core/src/main/java/com/sk89q/worldedit/extent/clipboard/io/SpongeSchematicReader.java

@@ -42,8 +42,12 @@ import com.sk89q.jnbt.NamedTag;
 import com.sk89q.jnbt.ShortTag;
 import com.sk89q.jnbt.StringTag;
 import com.sk89q.jnbt.Tag;
+<<<<<<< HEAD
 import com.sk89q.worldedit.BlockVector;
 import com.sk89q.worldedit.Vector;
+=======
+import com.sk89q.worldedit.WorldEdit;
+>>>>>>> 399e0ad5... Refactor vector system to be cleaner
 import com.sk89q.worldedit.WorldEditException;
 import com.sk89q.worldedit.blocks.BaseBlock;
 import com.sk89q.worldedit.entity.BaseEntity;
@@ -51,6 +55,7 @@ import com.sk89q.worldedit.extension.input.ParserContext;
 import com.sk89q.worldedit.extent.clipboard.BlockArrayClipboard;
 import com.sk89q.worldedit.extent.clipboard.Clipboard;
 import com.sk89q.worldedit.extent.clipboard.io.legacycompat.NBTCompatibilityHandler;
+import com.sk89q.worldedit.math.BlockVector3;
 import com.sk89q.worldedit.regions.CuboidRegion;
 import com.sk89q.worldedit.regions.Region;
 import com.sk89q.worldedit.world.block.BlockState;
@@ -103,10 +108,18 @@ public class SpongeSchematicReader extends NBTSchematicReader {
         return read(UUID.randomUUID());
     }
 
+<<<<<<< HEAD
     @Override
     public Clipboard read(UUID uuid) throws IOException {
         return readVersion1(uuid);
     }
+=======
+    private Clipboard readVersion1(Map<String, Tag> schematic) throws IOException {
+        BlockVector3 origin;
+        Region region;
+
+        Map<String, Tag> metadata = requireTag(schematic, "Metadata", CompoundTag.class).getValue();
+>>>>>>> 399e0ad5... Refactor vector system to be cleaner
 
     private int width, height, length;
     private int offsetX, offsetY, offsetZ;
@@ -121,12 +134,35 @@ public class SpongeSchematicReader extends NBTSchematicReader {
             }
             return fc;
         }
+<<<<<<< HEAD
         if (Settings.IMP.CLIPBOARD.USE_DISK) {
             return fc = new DiskOptimizedClipboard(size, 1, 1, uuid);
         } else if (Settings.IMP.CLIPBOARD.COMPRESSION_LEVEL == 0) {
             return fc = new CPUOptimizedClipboard(size, 1, 1);
         } else {
             return fc = new MemoryOptimizedClipboard(size, 1, 1);
+=======
+
+        BlockVector3 min = new BlockVector3(offsetParts[0], offsetParts[1], offsetParts[2]);
+
+        if (metadata.containsKey("WEOffsetX")) {
+            // We appear to have WorldEdit Metadata
+            int offsetX = requireTag(metadata, "WEOffsetX", IntTag.class).getValue();
+            int offsetY = requireTag(metadata, "WEOffsetY", IntTag.class).getValue();
+            int offsetZ = requireTag(metadata, "WEOffsetZ", IntTag.class).getValue();
+            BlockVector3 offset = new BlockVector3(offsetX, offsetY, offsetZ);
+            origin = min.subtract(offset);
+            region = new CuboidRegion(min, min.add(width, height, length).subtract(BlockVector3.ONE));
+        } else {
+            origin = min;
+            region = new CuboidRegion(origin, origin.add(width, height, length).subtract(BlockVector3.ONE));
+        }
+
+        int paletteMax = requireTag(schematic, "PaletteMax", IntTag.class).getValue();
+        Map<String, Tag> paletteObject = requireTag(schematic, "Palette", CompoundTag.class).getValue();
+        if (paletteObject.size() != paletteMax) {
+            throw new IOException("Differing given palette size to actual size");
+>>>>>>> 399e0ad5... Refactor vector system to be cleaner
         }
     }
 
@@ -152,6 +188,7 @@ public class SpongeSchematicReader extends NBTSchematicReader {
                 int index = ((IntTag) entry.getValue()).getValue();
                 palette[index] = (char) state.getOrdinal();
             }
+<<<<<<< HEAD
         });
         streamer.addReader("Schematic.BlockData.#", new NBTStreamer.LazyReader() {
             @Override
@@ -161,6 +198,23 @@ public class SpongeSchematicReader extends NBTSchematicReader {
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
+=======
+            palette.put(id, state);
+        }
+
+        byte[] blocks = requireTag(schematic, "BlockData", ByteArrayTag.class).getValue();
+
+        Map<BlockVector3, Map<String, Tag>> tileEntitiesMap = new HashMap<>();
+        try {
+            List<Map<String, Tag>> tileEntityTags = requireTag(schematic, "TileEntities", ListTag.class).getValue().stream()
+                    .map(tag -> (CompoundTag) tag)
+                    .map(CompoundTag::getValue)
+                    .collect(Collectors.toList());
+
+            for (Map<String, Tag> tileEntity : tileEntityTags) {
+                int[] pos = requireTag(tileEntity, "Pos", IntArrayTag.class).getValue();
+                tileEntitiesMap.put(new BlockVector3(pos[0], pos[1], pos[2]), tileEntity);
+>>>>>>> 399e0ad5... Refactor vector system to be cleaner
             }
         });
         streamer.addReader("Schematic.Biomes.#", new NBTStreamer.LazyReader() {
@@ -207,6 +261,7 @@ public class SpongeSchematicReader extends NBTSchematicReader {
                     Fawe.debug("Invalid entity: " + id);
                 }
             }
+<<<<<<< HEAD
         });
         streamer.readFully();
         if (fc == null) setupClipboard(length * width * height, uuid);
@@ -225,6 +280,21 @@ public class SpongeSchematicReader extends NBTSchematicReader {
                     for (int index = 0; index < volume; index++) {
                         BlockState state = BlockTypes.states[palette[fis.read()]];
                         fc.setBlock(index, state);
+=======
+            // index = (y * length + z) * width + x
+            int y = index / (width * length);
+            int z = (index % (width * length)) / width;
+            int x = (index % (width * length)) % width;
+            BlockState state = palette.get(value);
+            BlockVector3 pt = new BlockVector3(x, y, z);
+            try {
+                if (tileEntitiesMap.containsKey(pt)) {
+                    Map<String, Tag> values = Maps.newHashMap(tileEntitiesMap.get(pt));
+                    for (NBTCompatibilityHandler handler : COMPATIBILITY_HANDLERS) {
+                        if (handler.isAffectedBlock(state)) {
+                            handler.updateNBT(state, values);
+                        }
+>>>>>>> 399e0ad5... Refactor vector system to be cleaner
                     }
                 } else {
                     for (int index = 0; index < volume; index++) {

worldedit-core/src/main/java/com/sk89q/worldedit/extent/clipboard/io/SpongeSchematicWriter.java

@@ -27,15 +27,23 @@ import com.sk89q.jnbt.NBTConstants;
 import com.sk89q.jnbt.NBTOutputStream;
 import com.sk89q.jnbt.StringTag;
 import com.sk89q.jnbt.Tag;
+<<<<<<< HEAD
 import com.sk89q.worldedit.BlockVector;
 import com.sk89q.worldedit.Vector;
 import com.sk89q.worldedit.extent.clipboard.BlockArrayClipboard;
+=======
+>>>>>>> 399e0ad5... Refactor vector system to be cleaner
 import com.sk89q.worldedit.extent.clipboard.Clipboard;
+import com.sk89q.worldedit.math.BlockVector3;
 import com.sk89q.worldedit.regions.Region;
+<<<<<<< HEAD
 import com.sk89q.worldedit.world.block.BlockState;
 import com.sk89q.worldedit.world.block.BlockTypes;
 import net.jpountz.lz4.LZ4BlockInputStream;
 import net.jpountz.lz4.LZ4BlockOutputStream;
+=======
+import com.sk89q.worldedit.world.block.BaseBlock;
+>>>>>>> 399e0ad5... Refactor vector system to be cleaner
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
@@ -75,9 +83,15 @@ public class SpongeSchematicWriter implements ClipboardWriter {
     public void write1(Clipboard clipboard) throws IOException {
         // metadata
         Region region = clipboard.getRegion();
+<<<<<<< HEAD
         Vector origin = clipboard.getOrigin();
         BlockVector min = region.getMinimumPoint().toBlockVector();
         Vector offset = min.subtract(origin);
+=======
+        BlockVector3 origin = clipboard.getOrigin();
+        BlockVector3 min = region.getMinimumPoint();
+        BlockVector3 offset = min.subtract(origin);
+>>>>>>> 399e0ad5... Refactor vector system to be cleaner
         int width = region.getWidth();
         int height = region.getHeight();
         int length = region.getLength();
@@ -90,6 +104,7 @@ public class SpongeSchematicWriter implements ClipboardWriter {
         if (length > MAX_SIZE) {
             throw new IllegalArgumentException("Length of region too large for a .schematic");
         }
+<<<<<<< HEAD
         // output
         final DataOutput rawStream = outputStream.getOutputStream();
         outputStream.writeLazyCompoundTag("Schematic", out -> {
@@ -142,6 +157,49 @@ public class SpongeSchematicWriter implements ClipboardWriter {
                             }));
                             numTiles[0]++;
                             tilesOut.writeTagPayload(tile);
+=======
+
+        Map<String, Tag> schematic = new HashMap<>();
+        schematic.put("Version", new IntTag(1));
+
+        Map<String, Tag> metadata = new HashMap<>();
+        metadata.put("WEOffsetX", new IntTag(offset.getBlockX()));
+        metadata.put("WEOffsetY", new IntTag(offset.getBlockY()));
+        metadata.put("WEOffsetZ", new IntTag(offset.getBlockZ()));
+
+        schematic.put("Metadata", new CompoundTag(metadata));
+
+        schematic.put("Width", new ShortTag((short) width));
+        schematic.put("Height", new ShortTag((short) height));
+        schematic.put("Length", new ShortTag((short) length));
+
+        // The Sponge format Offset refers to the 'min' points location in the world. That's our 'Origin'
+        schematic.put("Offset", new IntArrayTag(new int[]{
+                min.getBlockX(),
+                min.getBlockY(),
+                min.getBlockZ(),
+        }));
+
+        int paletteMax = 0;
+        Map<String, Integer> palette = new HashMap<>();
+
+        List<CompoundTag> tileEntities = new ArrayList<>();
+
+        ByteArrayOutputStream buffer = new ByteArrayOutputStream(width * height * length);
+
+        for (int y = 0; y < height; y++) {
+            int y0 = min.getBlockY() + y;
+            for (int z = 0; z < length; z++) {
+                int z0 = min.getBlockZ() + z;
+                for (int x = 0; x < width; x++) {
+                    int x0 = min.getBlockX() + x;
+                    BlockVector3 point = new BlockVector3(x0, y0, z0);
+                    BaseBlock block = clipboard.getFullBlock(point);
+                    if (block.getNbtData() != null) {
+                        Map<String, Tag> values = new HashMap<>();
+                        for (Map.Entry<String, Tag> entry : block.getNbtData().getValue().entrySet()) {
+                            values.put(entry.getKey(), entry.getValue());
+>>>>>>> 399e0ad5... Refactor vector system to be cleaner
                         }
                         int ordinal = block.getOrdinal();
                         char value = palette[ordinal];