CatServer/patches/net/minecraft/tileentity/TileEntity.java.patch

--- ../src-base/minecraft/net/minecraft/tileentity/TileEntity.java
+++ ../src-work/minecraft/net/minecraft/tileentity/TileEntity.java
@@ -1,6 +1,7 @@
 package net.minecraft.tileentity;
 
 import javax.annotation.Nullable;
+
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockJukebox;
 import net.minecraft.block.state.IBlockState;
@@ -20,16 +21,23 @@
 import net.minecraftforge.fml.relauncher.SideOnly;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.bukkit.inventory.InventoryHolder;
+import org.spigotmc.CustomTimingsHandler;
 
-public abstract class TileEntity
+import catserver.server.inventory.CatInventoryUtils;
+
+public abstract class TileEntity implements net.minecraftforge.common.capabilities.ICapabilitySerializable<NBTTagCompound>
 {
+
     private static final Logger LOGGER = LogManager.getLogger();
     private static final RegistryNamespaced < ResourceLocation, Class <? extends TileEntity >> REGISTRY = new RegistryNamespaced < ResourceLocation, Class <? extends TileEntity >> ();
-    protected World world;
+    public World world;
     protected BlockPos pos = BlockPos.ORIGIN;
     protected boolean tileEntityInvalid;
     private int blockMetadata = -1;
     protected Block blockType;
+    public CustomTimingsHandler tickTimer = org.bukkit.craftbukkit.SpigotTimings.getTileEntityTimings(this); // Spigot
+    public boolean skipTick = false;
 
     public static void register(String id, Class <? extends TileEntity > clazz)
     {
@@ -60,6 +68,8 @@
     public void readFromNBT(NBTTagCompound compound)
     {
         this.pos = new BlockPos(compound.getInteger("x"), compound.getInteger("y"), compound.getInteger("z"));
+        if (compound.hasKey("ForgeData")) this.customTileData = compound.getCompoundTag("ForgeData");
+        if (this.capabilities != null && compound.hasKey("ForgeCaps")) this.capabilities.deserializeNBT(compound.getCompoundTag("ForgeCaps"));
     }
 
     public NBTTagCompound writeToNBT(NBTTagCompound compound)
@@ -81,6 +91,8 @@
             compound.setInteger("x", this.pos.getX());
             compound.setInteger("y", this.pos.getY());
             compound.setInteger("z", this.pos.getZ());
+            if (this.customTileData != null) compound.setTag("ForgeData", this.customTileData);
+            if (this.capabilities != null) compound.setTag("ForgeCaps", this.capabilities.serializeNBT());
             return compound;
         }
     }
@@ -90,10 +102,11 @@
     {
         TileEntity tileentity = null;
         String s = compound.getString("id");
+        Class <? extends TileEntity > oclass = null;
 
         try
         {
-            Class <? extends TileEntity > oclass = (Class)REGISTRY.getObject(new ResourceLocation(s));
+            oclass = (Class)REGISTRY.getObject(new ResourceLocation(s));
 
             if (oclass != null)
             {
@@ -103,6 +116,8 @@
         catch (Throwable throwable1)
         {
             LOGGER.error("Failed to create block entity {}", s, throwable1);
+            net.minecraftforge.fml.common.FMLLog.log.error("A TileEntity {}({}) has thrown an exception during loading, its state cannot be restored. Report this to the mod author",
+                    s, oclass == null ? null : oclass.getName(), throwable1);
         }
 
         if (tileentity != null)
@@ -115,6 +130,8 @@
             catch (Throwable throwable)
             {
                 LOGGER.error("Failed to load data for block entity {}", s, throwable);
+                net.minecraftforge.fml.common.FMLLog.log.error("A TileEntity {}({}) has thrown an exception during loading, its state cannot be restored. Report this to the mod author",
+                        s, oclass.getName(), throwable);
                 tileentity = null;
             }
         }
@@ -156,7 +173,6 @@
         }
     }
 
-    @SideOnly(Side.CLIENT)
     public double getDistanceSq(double x, double y, double z)
     {
         double d0 = (double)this.pos.getX() + 0.5D - x;
@@ -244,7 +260,7 @@
 
                     try
                     {
-                        return String.format("ID #%d (%s // %s)", i, Block.getBlockById(i).getUnlocalizedName(), Block.getBlockById(i).getClass().getCanonicalName());
+                        return String.format("ID #%d (%s // %s // %s)", i, Block.getBlockById(i).getUnlocalizedName(), Block.getBlockById(i).getClass().getName(), Block.getBlockById(i).getRegistryName());
                     }
                     catch (Throwable var3)
                     {
@@ -297,6 +313,204 @@
     {
     }
 
+    // -- BEGIN FORGE PATCHES --
+    /**
+     * Called when you receive a TileEntityData packet for the location this
+     * TileEntity is currently in. On the client, the NetworkManager will always
+     * be the remote server. On the server, it will be whomever is responsible for
+     * sending the packet.
+     *
+     * @param net The NetworkManager the packet originated from
+     * @param pkt The data packet
+     */
+    public void onDataPacket(net.minecraft.network.NetworkManager net, SPacketUpdateTileEntity pkt)
+    {
+    }
+
+    /**
+     * Called when the chunk's TE update tag, gotten from {@link #getUpdateTag()}, is received on the client.
+     * <p>
+     * Used to handle this tag in a special way. By default this simply calls {@link #readFromNBT(NBTTagCompound)}.
+     *
+     * @param tag The {@link NBTTagCompound} sent from {@link #getUpdateTag()}
+     */
+    public void handleUpdateTag(NBTTagCompound tag)
+    {
+        this.readFromNBT(tag);
+    }
+
+    /**
+     * Called when the chunk this TileEntity is on is Unloaded.
+     */
+    public void onChunkUnload()
+    {
+    }
+
+    private boolean isVanilla = getClass().getName().startsWith("net.minecraft.");
+    /**
+     * Called from Chunk.setBlockIDWithMetadata and Chunk.fillChunk, determines if this tile entity should be re-created when the ID, or Metadata changes.
+     * Use with caution as this will leave straggler TileEntities, or create conflicts with other TileEntities if not used properly.
+     *
+     * @param world Current world
+     * @param pos Tile's world position
+     * @param oldState The old ID of the block
+     * @param newState The new ID of the block (May be the same)
+     * @return true forcing the invalidation of the existing TE, false not to invalidate the existing TE
+     */
+    public boolean shouldRefresh(World world, BlockPos pos, IBlockState oldState, IBlockState newSate)
+    {
+        return isVanilla ? (oldState.getBlock() != newSate.getBlock()) : oldState != newSate;
+    }
+
+    public boolean shouldRenderInPass(int pass)
+    {
+        return pass == 0;
+    }
+
+    /**
+     * Sometimes default render bounding box: infinite in scope. Used to control rendering on {@link TileEntitySpecialRenderer}.
+     */
+    public static final net.minecraft.util.math.AxisAlignedBB INFINITE_EXTENT_AABB = new net.minecraft.util.math.AxisAlignedBB(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
+    /**
+     * Return an {@link AxisAlignedBB} that controls the visible scope of a {@link TileEntitySpecialRenderer} associated with this {@link TileEntity}
+     * Defaults to the collision bounding box {@link Block#getCollisionBoundingBoxFromPool(World, int, int, int)} associated with the block
+     * at this location.
+     *
+     * @return an appropriately size {@link AxisAlignedBB} for the {@link TileEntity}
+     */
+    @SideOnly(Side.CLIENT)
+    public net.minecraft.util.math.AxisAlignedBB getRenderBoundingBox()
+    {
+        net.minecraft.util.math.AxisAlignedBB bb = INFINITE_EXTENT_AABB;
+        Block type = getBlockType();
+        BlockPos pos = getPos();
+        if (type == Blocks.ENCHANTING_TABLE)
+        {
+            bb = new net.minecraft.util.math.AxisAlignedBB(pos, pos.add(1, 1, 1));
+        }
+        else if (type == Blocks.CHEST || type == Blocks.TRAPPED_CHEST)
+        {
+            bb = new net.minecraft.util.math.AxisAlignedBB(pos.add(-1, 0, -1), pos.add(2, 2, 2));
+        }
+        else if (type == Blocks.STRUCTURE_BLOCK)
+        {
+            bb = INFINITE_EXTENT_AABB;
+        }
+        else if (type != null && type != Blocks.BEACON)
+        {
+            net.minecraft.util.math.AxisAlignedBB cbb = null;
+            try
+            {
+                cbb = world.getBlockState(getPos()).getCollisionBoundingBox(world, pos).offset(pos);
+            }
+            catch (Exception e)
+            {
+                // We have to capture any exceptions that may occur here because BUKKIT servers like to send
+                // the tile entity data BEFORE the chunk data, you know, the OPPOSITE of what vanilla does!
+                // So we can not GARENTEE that the world state is the real state for the block...
+                // So, once again in the long line of US having to accommodate BUKKIT breaking things,
+                // here it is, assume that the TE is only 1 cubic block. Problem with this is that it may
+                // cause the TileEntity renderer to error further down the line! But alas, nothing we can do.
+                cbb = new net.minecraft.util.math.AxisAlignedBB(getPos().add(-1, 0, -1), getPos().add(1, 1, 1));
+            }
+            if (cbb != null) bb = cbb;
+        }
+        return bb;
+    }
+
+    /**
+     * Checks if this tile entity knows how to render its 'breaking' overlay effect.
+     * If this returns true, The TileEntitySpecialRenderer will be called again with break progress set.
+     * @return True to re-render tile with breaking effect.
+     */
+    public boolean canRenderBreaking()
+    {
+        Block block = this.getBlockType();
+        return (block instanceof net.minecraft.block.BlockChest ||
+                block instanceof net.minecraft.block.BlockEnderChest ||
+                block instanceof net.minecraft.block.BlockSign ||
+                block instanceof net.minecraft.block.BlockSkull);
+    }
+
+    private NBTTagCompound customTileData;
+
+    /**
+     * Gets a {@link NBTTagCompound} that can be used to store custom data for this tile entity.
+     * It will be written, and read from disc, so it persists over world saves.
+     *
+     * @return A compound tag for custom data
+     */
+    public NBTTagCompound getTileData()
+    {
+        if (this.customTileData == null)
+        {
+            this.customTileData = new NBTTagCompound();
+        }
+        return this.customTileData;
+    }
+
+    /**
+     * Determines if the player can overwrite the NBT data of this tile entity while they place it using a ItemStack.
+     * Added as a fix for MC-75630 - Exploit with signs and command blocks
+     * @return True to prevent NBT copy, false to allow.
+     */
+    public boolean restrictNBTCopy()
+    {
+        return this instanceof TileEntityCommandBlock ||
+               this instanceof TileEntityMobSpawner ||
+               this instanceof TileEntitySign;
+    }
+
+
+    /**
+     * Called when this is first added to the world (by {@link World#addTileEntity(TileEntity)}).
+     * Override instead of adding {@code if (firstTick)} stuff in update.
+     */
+    public void onLoad()
+    {
+        // NOOP
+    }
+
+    /**
+     * If the TileEntitySpecialRenderer associated with this TileEntity can be batched in with another renderers, and won't access the GL state.
+     * If TileEntity returns true, then TESR should have the same functionality as (and probably extend) the FastTESR class.
+     */
+    public boolean hasFastRenderer()
+    {
+        return false;
+    }
+
+    private net.minecraftforge.common.capabilities.CapabilityDispatcher capabilities;
+    public TileEntity()
+    {
+        capabilities = net.minecraftforge.event.ForgeEventFactory.gatherCapabilities(this);
+    }
+
+    @Override
+    public boolean hasCapability(net.minecraftforge.common.capabilities.Capability<?> capability, @Nullable net.minecraft.util.EnumFacing facing)
+    {
+        return capabilities == null ? false : capabilities.hasCapability(capability, facing);
+    }
+
+    @Override
+    @Nullable
+    public <T> T getCapability(net.minecraftforge.common.capabilities.Capability<T> capability, @Nullable net.minecraft.util.EnumFacing facing)
+    {
+        return capabilities == null ? null : capabilities.getCapability(capability, facing);
+    }
+
+    public void deserializeNBT(NBTTagCompound nbt)
+    {
+        this.readFromNBT(nbt);
+    }
+
+    public NBTTagCompound serializeNBT()
+    {
+        NBTTagCompound ret = new NBTTagCompound();
+        this.writeToNBT(ret);
+        return ret;
+    }
+
     static
     {
         register("furnace", TileEntityFurnace.class);
@@ -325,4 +539,9 @@
         register("shulker_box", TileEntityShulkerBox.class);
         register("bed", TileEntityBed.class);
     }
+
+    @Nullable
+    public InventoryHolder getOwner() {
+        return CatInventoryUtils.getOwner(world, pos); // CatServer - move to CatInventoryUtils
+    }
 }