1 files changed, 303 insertions, 0 deletions
diff --git a/src/main/java/gregtech/api/multitileentity/MultiTileEntityItemInternal.java b/src/main/java/gregtech/api/multitileentity/MultiTileEntityItemInternal.java
new file mode 100644
index 0000000000..897dbf7991
--- /dev/null
+++ b/src/main/java/gregtech/api/multitileentity/MultiTileEntityItemInternal.java
@@ -0,0 +1,303 @@
+package gregtech.api.multitileentity;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.metatileentity.CoverableTileEntity;
+import gregtech.api.multitileentity.interfaces.IItemUpdatable;
+import gregtech.api.multitileentity.interfaces.IMultiTileEntity;
+import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_AddToolTips;
+import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_GetMaxStackSize;
+import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_HasMultiBlockMachineRelevantData;
+import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_OnlyPlaceableWhenSneaking;
+import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_IgnoreEntityCollisionWhenPlacing;
+import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_CanPlace;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockSnow;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.IFluidContainerItem;
+
+import java.util.List;
+
+import static gregtech.GT_Mod.GT_FML_LOGGER;
+import static gregtech.api.enums.GT_Values.SIDE_TOP;
+import static gregtech.api.util.GT_Util.setTileEntity;
+
+public class MultiTileEntityItemInternal extends ItemBlock implements IFluidContainerItem, IItemUpdatable {
+    public final MultiTileEntityBlockInternal mBlock;
+
+    public MultiTileEntityItemInternal(Block aBlock) {
+        super(aBlock);
+        setMaxDamage(0);
+        setHasSubtypes(true);
+        mBlock = (MultiTileEntityBlockInternal)aBlock;
+    }
+    @Override
+    @SuppressWarnings("unchecked")
+    public void addInformation(ItemStack aStack, EntityPlayer aPlayer, List aList, boolean aF3_H) {
+        final MultiTileEntityContainer tTileEntityContainer = mBlock.mMultiTileEntityRegistry.getNewTileEntityContainer(aStack);
+        if (tTileEntityContainer == null) {
+            aList.add("INVALID ITEM!");
+            return;
+        }
+        if (tTileEntityContainer.mTileEntity instanceof IMTE_AddToolTips) {
+            try {
+                ((IMTE_AddToolTips) tTileEntityContainer.mTileEntity).addToolTips(aList, aStack, aF3_H);
+            } catch (Throwable e) {
+                GT_FML_LOGGER.error("addInformation", e);
+            }
+        }
+        final NBTTagCompound aNBT = aStack.getTagCompound();
+        CoverableTileEntity.addInstalledCoversInformation(aNBT, aList);
+        // TODO: Add anything else relevant
+    }
+
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    @SuppressWarnings("unchecked")
+    public void getSubItems(Item aItem, CreativeTabs aTab, List aList) {
+        for (MultiTileEntityClassContainer tClass : mBlock.mMultiTileEntityRegistry.mRegistrations) {
+            if (!tClass.mHidden) {
+                if (((IMultiTileEntity) tClass.mCanonicalTileEntity).getSubItems(mBlock, aItem, aTab, aList, tClass.mID)) {
+                    aList.add(mBlock.mMultiTileEntityRegistry.getItem(tClass.mID));
+                }
+            }
+        }
+    }
+
+    @Override
+    public boolean onItemUse(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, int aSide, float aHitX, float aHitY, float aHitZ) {
+        if (aY < 0 || aY > aWorld.getHeight()) return false;
+        try {
+            final Block tClickedBlock = aWorld.getBlock(aX, aY, aZ);
+            if (tClickedBlock instanceof BlockSnow && (aWorld.getBlockMetadata(aX, aY, aZ) & 7) < 1) {
+                aSide = SIDE_TOP;
+            } else if (tClickedBlock != Blocks.vine && tClickedBlock != Blocks.tallgrass && tClickedBlock != Blocks.deadbush && !tClickedBlock.isReplaceable(aWorld, aX, aY, aZ)) {
+                aX += GT_Values.OFFX[aSide];
+                aY += GT_Values.OFFY[aSide];
+                aZ += GT_Values.OFFZ[aSide];
+            }
+            final Block tReplacedBlock = aWorld.getBlock(aX, aY, aZ);
+
+            if (!tReplacedBlock.isReplaceable(aWorld, aX, aY, aZ) || !mBlock.canReplace(aWorld, aX, aY, aZ, aSide, aStack)) return false;
+            if (aStack.stackSize == 0 || (aPlayer != null && !aPlayer.canPlayerEdit(aX, aY, aZ, aSide, aStack))) return false;
+
+            final MultiTileEntityContainer aMTEContainer = mBlock.mMultiTileEntityRegistry.getNewTileEntityContainer(aWorld, aX, aY, aZ, aStack);
+
+            if (aMTEContainer != null
+                && (aPlayer == null || aPlayer.isSneaking() || !(aMTEContainer.mTileEntity instanceof IMTE_OnlyPlaceableWhenSneaking) || !((IMTE_OnlyPlaceableWhenSneaking) aMTEContainer.mTileEntity).onlyPlaceableWhenSneaking())
+                && (
+                    aWorld.checkNoEntityCollision(AxisAlignedBB.getBoundingBox(aX, aY, aZ, aX+1, aY+1, aZ+1))
+                    || (aMTEContainer.mTileEntity instanceof IMTE_IgnoreEntityCollisionWhenPlacing && ((IMTE_IgnoreEntityCollisionWhenPlacing)aMTEContainer.mTileEntity).ignoreEntityCollisionWhenPlacing(aStack, aPlayer, aWorld, aX, aY, aZ, (byte)aSide, aHitX, aHitY, aHitZ))
+                )
+                && (!(aMTEContainer.mTileEntity instanceof IMTE_CanPlace) || ((IMTE_CanPlace)aMTEContainer.mTileEntity).canPlace(aStack, aPlayer, aWorld, aX, aY, aZ, (byte)aSide, aHitX, aHitY, aHitZ))
+                && aWorld.setBlock(aX, aY, aZ, aMTEContainer.mBlock, 15 - aMTEContainer.mBlockMetaData, 2))
+            {
+                aMTEContainer.setMultiTile(aWorld, aX, aY, aZ);
+
+                try {
+                    if (((IMultiTileEntity) aMTEContainer.mTileEntity).onPlaced(aStack, aPlayer, aWorld, aX, aY, aZ, (byte) aSide, aHitX, aHitY, aHitZ)) {
+                        aWorld.playSoundEffect(
+                            aX + 0.5, aY + 0.5, aZ + 0.5, aMTEContainer.mBlock.stepSound.func_150496_b(), (aMTEContainer.mBlock.stepSound.getVolume() + 1) / 2,
+                            aMTEContainer.mBlock.stepSound.getPitch() * 0.8F
+                        );
+                    }
+                } catch (Throwable e) {
+                    GT_FML_LOGGER.error("onPlaced", e);
+                }
+                try {
+                    if (aMTEContainer.mTileEntity instanceof IMTE_HasMultiBlockMachineRelevantData && (((IMTE_HasMultiBlockMachineRelevantData) aMTEContainer.mTileEntity).hasMultiBlockMachineRelevantData())) {
+                            GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ);
+                    }
+                } catch (Throwable e) {
+                    GT_FML_LOGGER.error("causeMachineUpdate", e);
+                }
+                try {
+                    if (!aWorld.isRemote) {
+                        aWorld.notifyBlockChange(aX, aY, aZ, tReplacedBlock);
+                        aWorld.func_147453_f/*updateNeighborsAboutBlockChange*/(aX, aY, aZ, aMTEContainer.mBlock);
+                    }
+                } catch (Throwable e) {
+                    GT_FML_LOGGER.error("notifyBlockChange", e);
+                }
+                try {
+                    ((IMultiTileEntity)aMTEContainer.mTileEntity).onTileEntityPlaced();
+                } catch (Throwable e) {
+                    GT_FML_LOGGER.error("onTileEntityPlaced", e);
+                }
+                try {
+                    aWorld.func_147451_t/*updateAllLightTypes*/(aX, aY, aZ);
+                } catch (Throwable e) {
+                    GT_FML_LOGGER.error("updateAllLightTypes", e);
+                }
+
+                aStack.stackSize--;
+                return true;
+            }
+        } catch (Throwable e) {
+            GT_FML_LOGGER.error("onItemUse", e);
+        }
+        return false;
+    }
+
+    @Override
+    public void updateItemStack(ItemStack aStack) {
+        final MultiTileEntityClassContainer tContainer = mBlock.mMultiTileEntityRegistry.getClassContainer(aStack);
+        if (tContainer == null) return;
+        final MultiTileEntityContainer tTileEntityContainer = mBlock.mMultiTileEntityRegistry.getNewTileEntityContainer(aStack);
+        if (tTileEntityContainer != null && tTileEntityContainer.mTileEntity instanceof IItemUpdatable) {
+            ((IItemUpdatable)tTileEntityContainer.mTileEntity).updateItemStack(aStack);
+        }
+    }
+    @Override
+    public void updateItemStack(ItemStack aStack, World aWorld, int aX, int aY, int aZ) {
+        final MultiTileEntityClassContainer tContainer = mBlock.mMultiTileEntityRegistry.getClassContainer(aStack);
+        if (tContainer == null) return;
+        final MultiTileEntityContainer tTileEntityContainer = mBlock.mMultiTileEntityRegistry.getNewTileEntityContainer(aStack);
+        if (tTileEntityContainer != null && tTileEntityContainer.mTileEntity instanceof IItemUpdatable) {
+            ((IItemUpdatable)tTileEntityContainer.mTileEntity).updateItemStack(aStack, aWorld, aX, aY, aZ);
+        }
+    }
+
+    @Override
+    public int getItemStackLimit(ItemStack aStack) {
+        final MultiTileEntityClassContainer tContainer = mBlock.mMultiTileEntityRegistry.getClassContainer(aStack);
+        if (tContainer == null) return 1;
+        final MultiTileEntityContainer tTileEntityContainer = mBlock.mMultiTileEntityRegistry.getNewTileEntityContainer(aStack);
+        if (tTileEntityContainer != null && tTileEntityContainer.mTileEntity instanceof IMTE_GetMaxStackSize) {
+            return ((IMTE_GetMaxStackSize)tTileEntityContainer.mTileEntity).getMaxStackSize(aStack, tContainer.mStackSize);
+        }
+        return tContainer.mStackSize;
+    }
+
+    @Override
+    public void onCreated(ItemStack aStack, World aWorld, EntityPlayer aPlayer) {
+        updateItemStack(aStack);
+    }
+
+    @Override
+    public FluidStack getFluid(ItemStack aStack) {
+        final MultiTileEntityContainer tTileEntityContainer = mBlock.mMultiTileEntityRegistry.getNewTileEntityContainer(aStack);
+        if (tTileEntityContainer != null && tTileEntityContainer.mTileEntity instanceof IFluidContainerItem) {
+            final FluidStack rFluid = ((IFluidContainerItem)tTileEntityContainer.mTileEntity).getFluid(aStack);
+            updateItemStack(aStack);
+            return rFluid;
+        }
+        return null;
+    }
+
+    @Override
+    public int getCapacity(ItemStack aStack) {
+        final MultiTileEntityContainer tTileEntityContainer = mBlock.mMultiTileEntityRegistry.getNewTileEntityContainer(aStack);
+        if (tTileEntityContainer != null && tTileEntityContainer.mTileEntity instanceof IFluidContainerItem) {
+            final int rCapacity = ((IFluidContainerItem)tTileEntityContainer.mTileEntity).getCapacity(aStack);
+            updateItemStack(aStack);
+            return rCapacity;
+        }
+        return 0;
+    }
+
+    @Override
+    public int fill(ItemStack aStack, FluidStack aFluid, boolean aDoFill) {
+        final MultiTileEntityContainer tTileEntityContainer = mBlock.mMultiTileEntityRegistry.getNewTileEntityContainer(aStack);
+        if (tTileEntityContainer != null && tTileEntityContainer.mTileEntity instanceof IFluidContainerItem) {
+            final int tFilled = ((IFluidContainerItem)tTileEntityContainer.mTileEntity).fill(aStack, aFluid, aDoFill);
+            updateItemStack(aStack);
+            return tFilled;
+        }
+        return 0;
+    }
+
+    @Override
+    public FluidStack drain(ItemStack aStack, int aMaxDrain, boolean aDoDrain) {
+        final MultiTileEntityContainer tTileEntityContainer = mBlock.mMultiTileEntityRegistry.getNewTileEntityContainer(aStack);
+        if (tTileEntityContainer != null && tTileEntityContainer.mTileEntity instanceof IFluidContainerItem) {
+            final FluidStack rFluid = ((IFluidContainerItem)tTileEntityContainer.mTileEntity).drain(aStack, aMaxDrain, aDoDrain);
+            updateItemStack(aStack);
+            return rFluid;
+        }
+        return null;
+    }
+
+    @Override
+    public boolean func_150936_a/*canPlaceAtSide*/(World aWorld, int aX, int aY, int aZ, int aSide, EntityPlayer aPlayer, ItemStack aStack) {
+        return true;
+    }
+
+    @Override
+    public final String getUnlocalizedName() {
+        return mBlock.mMultiTileEntityRegistry.mNameInternal;
+    }
+
+    @Override
+    public final String getUnlocalizedName(ItemStack aStack) {
+        return mBlock.mMultiTileEntityRegistry.mNameInternal + "." + getDamage(aStack);
+    }
+
+    @Override
+    public int getSpriteNumber() {
+        return 0;
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerIcons(IIconRegister aRegister) {
+        /* Empty */
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public IIcon getIconFromDamage(int aMeta) {
+        itemIcon = Items.bread.getIconFromDamage(0);
+        return itemIcon; /* Fixes Eating Animation Particles. */
+    }
+
+    @Override
+    public boolean doesContainerItemLeaveCraftingGrid(ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public final boolean getShareTag() {
+        return true;  // just to be sure
+    }
+
+    @Override
+    public int getItemEnchantability() {
+        return 0;
+    }
+
+    @Override
+    public boolean getIsRepairable(ItemStack aStack, ItemStack aMaterial) {
+        return false;
+    }
+
+    @Override
+    public ItemStack getContainerItem(ItemStack aStack) {
+        return null;
+    }
+
+    @Override
+    public final boolean hasContainerItem(ItemStack aStack) {
+        return getContainerItem(aStack) != null;
+    }
+
+    @Override
+    public boolean isBookEnchantable(ItemStack aStack, ItemStack aBook) {
+        return false;
+    }
+}