src/main/java/net/glowstone/io/nbt/NbtSerialization.java

package net.glowstone.io.nbt;

import net.glowstone.GlowServer;
import net.glowstone.constants.ItemIds;
import net.glowstone.inventory.GlowItemFactory;
import net.glowstone.util.nbt.CompoundTag;
import net.glowstone.util.nbt.TagType;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.inventory.ItemStack;
import org.bukkit.util.Vector;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.UUID;

/**
 * Utility methods for transforming various objects to and from NBT.
 */
public final class NbtSerialization {

    private NbtSerialization() {
    }

    /**
     * Read an item stack in from an NBT tag. Returns null if no item exists.
     * @param tag The tag to read from.
     * @return The resulting ItemStack, or null.
     */
    public static ItemStack readItem(CompoundTag tag) {
        final Material material;
        if (tag.isString("id")) {
            material = ItemIds.getMaterial(tag.getString("id"));
        } else if (tag.isShort("id")) {
            material = Material.getMaterial(tag.getShort("id"));
        } else {
            return null;
        }
        final short damage = tag.isShort("Damage") ? tag.getShort("Damage") : 0;
        final byte count = tag.isByte("Count") ? tag.getByte("Count") : 0;

        if (material == null || material == Material.AIR || count == 0) {
            return null;
        }
        ItemStack stack = new ItemStack(material, count, damage);
        if (tag.isCompound("tag")) {
            stack.setItemMeta(GlowItemFactory.instance().readNbt(material, tag.getCompound("tag")));
        }
        return stack;
    }

    /**
     * Write an item stack to an NBT tag. Null stacks produce an empty tag,
     * and if slot is negative it is omitted from the result.
     * @param stack The stack to write, or null.
     * @param slot The slot, or negative to omit.
     * @return The resulting tag.
     */
    public static CompoundTag writeItem(ItemStack stack, int slot) {
        CompoundTag tag = new CompoundTag();
        if (stack == null || stack.getType() == Material.AIR) {
            return tag;
        }
        tag.putString("id", ItemIds.getName(stack.getType()));
        tag.putShort("Damage", stack.getDurability());
        tag.putByte("Count", stack.getAmount());
        if (slot >= 0) {
            tag.putByte("Slot", slot);
        }
        CompoundTag meta = GlowItemFactory.instance().writeNbt(stack.getItemMeta());
        if (meta != null) {
            tag.putCompound("tag", meta);
        }
        return tag;
    }

    /**
     * Read a full inventory (players, chests, etc.) from a compound list.
     * @param tagList The list of CompoundTags to read from.
     * @param start The slot number to consider the inventory's start.
     * @param size The desired size of the inventory.
     * @return An array with the contents of the inventory.
     */
    public static ItemStack[] readInventory(List<CompoundTag> tagList, int start, int size) {
        ItemStack[] items = new ItemStack[size];
        for (CompoundTag tag : tagList) {
            byte slot = tag.isByte("Slot") ? tag.getByte("Slot") : 0;
            if (slot >= start && slot < start + size) {
                items[slot - start] = readItem(tag);
            }
        }
        return items;
    }

    /**
     * Write a full inventory (players, chests, etc.) to a compound list.
     * @param items An array with the contents of the inventory.
     * @param start The slot number to consider the inventory's start.
     * @return The list of CompoundTags.
     */
    public static List<CompoundTag> writeInventory(ItemStack[] items, int start) {
        List<CompoundTag> out = new ArrayList<>();
        for (int i = 0; i < items.length; i++) {
            ItemStack stack = items[i];
            if (stack != null) {
                out.add(writeItem(stack, start + i));
            }
        }
        return out;
    }

    /**
     * Attempt to resolve a world based on the contents of a compound tag.
     * @param server The server to look up worlds in.
     * @param compound The tag to read the world from.
     * @return The world, or null if none could be found.
     */
    public static World readWorld(GlowServer server, CompoundTag compound) {
        World world = null;
        if (compound.isLong("WorldUUIDLeast") && compound.isLong("WorldUUIDMost")) {
            long uuidLeast = compound.getLong("WorldUUIDLeast");
            long uuidMost = compound.getLong("WorldUUIDMost");
            world = server.getWorld(new UUID(uuidMost, uuidLeast));
        }
        if (world == null && compound.isString("World")) {
            world = server.getWorld(compound.getString("World"));
        }
        if (world == null && compound.isInt("Dimension")) {
            int dim = compound.getInt("Dimension");
            for (World sWorld : server.getWorlds()) {
                if (sWorld.getEnvironment().getId() == dim) {
                    world = sWorld;
                    break;
                }
            }
        }
        return world;
    }

    /**
     * Save world identifiers (UUID and dimension) to a compound tag for
     * later lookup.
     * @param world The world to identify.
     * @param compound The tag to write to.
     */
    public static void writeWorld(World world, CompoundTag compound) {
        UUID worldUUID = world.getUID();
        // world UUID used by Bukkit and code above
        compound.putLong("WorldUUIDMost", worldUUID.getMostSignificantBits());
        compound.putLong("WorldUUIDLeast", worldUUID.getLeastSignificantBits());
        // leave a Dimension value for possible Vanilla use
        compound.putInt("Dimension", world.getEnvironment().getId());
    }

    /**
     * Read a Location from the "Pos" and "Rotation" children of a tag. If
     * "Pos" is absent or invalid, null is returned. If "Rotation" is absent
     * or invalid, it is skipped and a location without rotation is returned.
     * @param world The world of the location (see readWorld).
     * @param tag The tag to read from.
     * @return The location, or null.
     */
    public static Location listTagsToLocation(World world, CompoundTag tag) {
        // check for position list
        if (tag.isList("Pos", TagType.DOUBLE)) {
            List<Double> pos = tag.getList("Pos", TagType.DOUBLE);
            if (pos.size() == 3) {
                Location location = new Location(world, pos.get(0), pos.get(1), pos.get(2));

                // check for rotation
                if (tag.isList("Rotation", TagType.FLOAT)) {
                    List<Float> rot = tag.getList("Rotation", TagType.FLOAT);
                    if (rot.size() == 2) {
                        location.setYaw(rot.get(0));
                        location.setPitch(rot.get(1));
                    }
                }

                return location;
            }
        }

        return null;
    }

    /**
     * Write a Location to the "Pos" and "Rotation" children of a tag. Does
     * not save world information, use writeWorld instead.
     * @param loc The location to write.
     * @param tag The tag to write to.
     */
    public static void locationToListTags(Location loc, CompoundTag tag) {
        tag.putList("Pos", TagType.DOUBLE, Arrays.asList(loc.getX(), loc.getY(), loc.getZ()));
        tag.putList("Rotation", TagType.FLOAT, Arrays.asList(loc.getYaw(), loc.getPitch()));
    }

    /**
     * Create a Vector from a list of doubles. If the list is invalid, a
     * zero vector is returned.
     * @param list The list to read from.
     * @return The Vector.
     */
    public static Vector listToVector(List<Double> list) {
        if (list.size() == 3) {
            return new Vector(list.get(0), list.get(1), list.get(2));
        }
        return new Vector(0, 0, 0);
    }

    /**
     * Create a list of doubles from a Vector.
     * @param vec The vector to write.
     * @return The list.
     */
    public static List<Double> vectorToList(Vector vec) {
        return Arrays.asList(vec.getX(), vec.getY(), vec.getZ());
    }

}