ItemMapLocation.java

/** Copyright (c) 2011-2015, SpaceToad and the BuildCraft Team http://www.mod-buildcraft.com
 * <p/>
 * BuildCraft is distributed under the terms of the Minecraft Mod Public License 1.0, or MMPL. Please check the contents
 * of the license located in http://www.mod-buildcraft.com/MMPL-1.0.txt */
package buildcraft.core;

import java.util.ArrayList;
import java.util.List;

import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.world.World;

import net.minecraftforge.common.util.Constants;

import buildcraft.api.core.IAreaProvider;
import buildcraft.api.core.IBox;
import buildcraft.api.core.IPathProvider;
import buildcraft.api.core.IZone;
import buildcraft.api.items.IMapLocation;
import buildcraft.core.lib.items.ItemBuildCraft;
import buildcraft.core.lib.utils.BCStringUtils;
import buildcraft.core.lib.utils.ModelHelper;
import buildcraft.core.lib.utils.NBTUtils;
import buildcraft.robotics.ZonePlan;

public class ItemMapLocation extends ItemBuildCraft implements IMapLocation {
    private static final String[] STORAGE_TAGS = "x,y,z,side,xMin,xMax,yMin,yMax,zMin,zMax,path,chunkMapping,name".split(",");

    public ItemMapLocation() {
        super(BCCreativeTab.get("main"));
        setHasSubtypes(true);
    }

    @Override
    public int getItemStackLimit(ItemStack stack) {
        return MapLocationType.getFromStack(stack) == MapLocationType.CLEAN ? 16 : 1;
    }

    @Override
    public void addInformation(ItemStack stack, EntityPlayer player, @SuppressWarnings("rawtypes") List list, boolean advanced) {
        @SuppressWarnings("unchecked")
        List<String> strings = list;
        NBTTagCompound cpt = NBTUtils.getItemData(stack);

        if (cpt.hasKey("name")) {
            String name = cpt.getString("name");
            if (name.length() > 0) {
                strings.add(name);
            }
        }

        MapLocationType type = MapLocationType.getFromStack(stack);
        switch (type) {
            case SPOT: {
                int x = cpt.getInteger("x");
                int y = cpt.getInteger("y");
                int z = cpt.getInteger("z");
                EnumFacing side = EnumFacing.values()[cpt.getByte("side")];

                strings.add(BCStringUtils.localize("{" + x + ", " + y + ", " + z + ", " + side + "}"));
                break;
            }
            case AREA: {
                int x = cpt.getInteger("xMin");
                int y = cpt.getInteger("yMin");
                int z = cpt.getInteger("zMin");
                int xLength = cpt.getInteger("xMax") - x + 1;
                int yLength = cpt.getInteger("yMax") - y + 1;
                int zLength = cpt.getInteger("zMax") - z + 1;

                strings.add(BCStringUtils.localize("{" + x + ", " + y + ", " + z + "} + {" + xLength + " x " + yLength + " x " + zLength + "}"));
                break;
            }
            case PATH: {
                NBTTagList pathNBT = (NBTTagList) cpt.getTag("path");
                BlockPos first = NBTUtils.readBlockPos(pathNBT.get(0));

                int x = first.getX();
                int y = first.getY();
                int z = first.getZ();

                strings.add(BCStringUtils.localize("{" + x + ", " + y + ", " + z + "} + " + (pathNBT.tagCount() - 1) + " elements"));
                break;
            }
            default: {
                break;
            }
        }
    }

    @Override
    public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player) {
        if (world.isRemote) {
            return stack;
        }
        if (player.isSneaking()) {
            return clearMarkerData(stack);
        }
        return stack;
    }

    private static ItemStack clearMarkerData(ItemStack stack) {
        if (MapLocationType.getFromStack(stack) == MapLocationType.CLEAN) {
            return stack;
        }
        NBTTagCompound nbt = NBTUtils.getItemData(stack);
        for (String key : STORAGE_TAGS) {
            nbt.removeTag(key);
        }
        if (nbt.hasNoTags()) {
            stack.setTagCompound(null);
        }
        MapLocationType.CLEAN.setToStack(stack);
        return stack;
    }

    @Override
    public boolean onItemUseFirst(ItemStack stack, EntityPlayer player, World world, BlockPos pos, EnumFacing side, float par8, float par9, float par10) {
        if (world.isRemote) {
            return false;
        }

        if (MapLocationType.getFromStack(stack) != MapLocationType.CLEAN) {
            return false;
        }

        ItemStack modified = stack;

        if (stack.stackSize > 1) {
            modified = stack.copy();
            stack.stackSize--;
            modified.stackSize = 1;
        }

        TileEntity tile = world.getTileEntity(pos);
        NBTTagCompound cpt = NBTUtils.getItemData(modified);

        if (tile instanceof IPathProvider) {
            MapLocationType.PATH.setToStack(modified);

            NBTTagList pathNBT = new NBTTagList();

            for (BlockPos index : ((IPathProvider) tile).getPath()) {
                pathNBT.appendTag(NBTUtils.writeBlockPos(index));
            }

            cpt.setTag("path", pathNBT);
        } else if (tile instanceof IAreaProvider) {
            MapLocationType.AREA.setToStack(modified);

            IAreaProvider areaTile = (IAreaProvider) tile;

            cpt.setInteger("xMin", areaTile.min().getX());
            cpt.setInteger("yMin", areaTile.min().getY());
            cpt.setInteger("zMin", areaTile.min().getZ());
            cpt.setInteger("xMax", areaTile.max().getX());
            cpt.setInteger("yMax", areaTile.max().getY());
            cpt.setInteger("zMax", areaTile.max().getZ());

        } else {
            MapLocationType.SPOT.setToStack(modified);

            cpt.setByte("side", (byte) side.getIndex());
            cpt.setInteger("x", pos.getX());
            cpt.setInteger("y", pos.getY());
            cpt.setInteger("z", pos.getZ());
        }

        if (stack != modified) {
            if (!player.inventory.addItemStackToInventory(modified)) {
                player.dropItem(modified, false, true);
            } else {
                player.inventoryContainer.detectAndSendChanges();
            }
        }

        return true;
    }

    @Override
    public IBox getBox(ItemStack item) {
        MapLocationType type = MapLocationType.getFromStack(item);

        switch (type) {
            case AREA: {
                return getAreaBox(item);
            }
            case SPOT: {
                return getPointBox(item);
            }
            default: {
                return null;
            }
        }
    }

    public static IBox getAreaBox(ItemStack item) {
        NBTTagCompound cpt = NBTUtils.getItemData(item);
        int xMin = cpt.getInteger("xMin");
        int yMin = cpt.getInteger("yMin");
        int zMin = cpt.getInteger("zMin");
        BlockPos min = new BlockPos(xMin, yMin, zMin);

        int xMax = cpt.getInteger("xMax");
        int yMax = cpt.getInteger("yMax");
        int zMax = cpt.getInteger("zMax");
        BlockPos max = new BlockPos(xMax, yMax, zMax);

        return new Box(min, max);
    }

    public static IBox getPointBox(ItemStack item) {
        NBTTagCompound cpt = NBTUtils.getItemData(item);
        MapLocationType type = MapLocationType.getFromStack(item);

        switch (type) {
            case SPOT: {
                int x = cpt.getInteger("x");
                int y = cpt.getInteger("y");
                int z = cpt.getInteger("z");

                BlockPos pos = new BlockPos(x, y, z);

                return new Box(pos, pos);
            }
            default: {
                return null;
            }
        }
    }

    public static EnumFacing getPointFace(ItemStack stack) {
        NBTTagCompound cpt = NBTUtils.getItemData(stack);
        return EnumFacing.VALUES[cpt.getByte("side")];
    }

    @Override
    public EnumFacing getPointSide(ItemStack item) {
        NBTTagCompound cpt = NBTUtils.getItemData(item);
        MapLocationType type = MapLocationType.getFromStack(item);

        if (type == MapLocationType.SPOT) {
            return EnumFacing.values()[cpt.getByte("side")];
        } else {
            return null;
        }
    }

    @Override
    public BlockPos getPoint(ItemStack item) {
        NBTTagCompound cpt = NBTUtils.getItemData(item);
        MapLocationType type = MapLocationType.getFromStack(item);

        if (type == MapLocationType.SPOT) {
            return new BlockPos(cpt.getInteger("x"), cpt.getInteger("y"), cpt.getInteger("z"));
        } else {
            return null;
        }
    }

    @Override
    public IZone getZone(ItemStack item) {
        NBTTagCompound cpt = NBTUtils.getItemData(item);
        MapLocationType type = MapLocationType.getFromStack(item);
        switch (type) {
            case ZONE: {
                ZonePlan plan = new ZonePlan();
                plan.readFromNBT(cpt);
                return plan;
            }
            case AREA: {
                return getBox(item);
            }
            case PATH: {
                return getPointBox(item);
            }
            default: {
                return null;
            }
        }
    }

    @Override
    public List<BlockPos> getPath(ItemStack item) {
        NBTTagCompound cpt = NBTUtils.getItemData(item);
        MapLocationType type = MapLocationType.getFromStack(item);
        switch (type) {
            case PATH: {
                List<BlockPos> indexList = new ArrayList<>();
                NBTTagList pathNBT = cpt.getTagList("path", Constants.NBT.TAG_COMPOUND);
                for (int i = 0; i < pathNBT.tagCount(); i++) {
                    indexList.add(NBTUtils.readBlockPos(pathNBT.getCompoundTagAt(i)));
                }
                return indexList;
            }
            case SPOT: {
                List<BlockPos> indexList = new ArrayList<>();
                indexList.add(new BlockPos(cpt.getInteger("x"), cpt.getInteger("y"), cpt.getInteger("z")));
                return indexList;
            }
            default: {
                return null;
            }
        }
    }

    public static void setZone(ItemStack item, ZonePlan plan) {
        NBTTagCompound cpt = NBTUtils.getItemData(item);
        MapLocationType.ZONE.setToStack(item);
        plan.writeToNBT(cpt);
    }

    @Override
    public String getName(ItemStack item) {
        return NBTUtils.getItemData(item).getString("name");
    }

    @Override
    public boolean setName(ItemStack item, String name) {
        NBTTagCompound cpt = NBTUtils.getItemData(item);
        cpt.setString("name", name);
        return true;
    }

    @Override
    public void registerModels() {
        ModelHelper.registerItemModel(this, MapLocationType.CLEAN.meta, "/clean");
        ModelHelper.registerItemModel(this, MapLocationType.SPOT.meta, "/spot");
        ModelHelper.registerItemModel(this, MapLocationType.AREA.meta, "/area");
        ModelHelper.registerItemModel(this, MapLocationType.PATH.meta, "/path");
        ModelHelper.registerItemModel(this, MapLocationType.ZONE.meta, "/zone");
    }
}