internal SingleContainerInterface(World.WorldManager world, InterfaceType interfaceType, UniversalCoords coords, sbyte slotCount)
            : base(world, interfaceType, slotCount)
        {
            Coords = coords;

            Load();
        }

 public void ForNSEW(UniversalCoords coords, ForEachBlock predicate)
 {
     predicate(UniversalCoords.FromWorld(coords.WorldX - 1, coords.WorldY, coords.WorldZ));
     predicate(UniversalCoords.FromWorld(coords.WorldX + 1, coords.WorldY, coords.WorldZ));
     predicate(UniversalCoords.FromWorld(coords.WorldX, coords.WorldY, coords.WorldZ - 1));
     predicate(UniversalCoords.FromWorld(coords.WorldX, coords.WorldY, coords.WorldZ + 1));
 }

        /// <summary>
        /// Opens the Workbench and specifies where items should be dropped if exiting the workbench with items still in it.
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="z"></param>
        public virtual void Open(UniversalCoords coords)
        {
            _useProvidedDropCoordinates = true;
            _DropCoords = coords;

            this.Open();
        }

        /// <summary>
        /// Creates a Large Chest interface for the two chests specified (North or East chest, and South or West chest)
        /// </summary>
        /// <param name="world"></param>
        /// <param name="neChest">The North or East chest coordinates</param>
        /// <param name="swChest">The South or West chest coordinates</param>
        public LargeChestInterface(World.WorldManager world, UniversalCoords neChest, UniversalCoords swChest)
            : base(world, InterfaceType.Chest, 54)
        {
            NEChest = neChest;
            SWChest = swChest;

            Load();
        }

 public static void StopBurning(WorldManager world, UniversalCoords coords)
 {
     string id = String.Format("{0}-{1},{2},{3}", world.Name, coords.WorldX, coords.WorldY, coords.WorldZ);
     lock (_staticLock)
     {
         if (_furnaceInstances.ContainsKey(id))
             _furnaceInstances[id].StopBurning();
     }
 }

 public void ForAdjacent(UniversalCoords coords, ForEachBlock predicate)
 {
     predicate(UniversalCoords.FromWorld(coords.WorldX - 1, coords.WorldY, coords.WorldZ));
     predicate(UniversalCoords.FromWorld(coords.WorldX + 1, coords.WorldY, coords.WorldZ));
     predicate(UniversalCoords.FromWorld(coords.WorldX, coords.WorldY, coords.WorldZ - 1));
     predicate(UniversalCoords.FromWorld(coords.WorldX, coords.WorldY, coords.WorldZ + 1));
     if (coords.BlockY > 0)
         predicate(UniversalCoords.FromWorld(coords.WorldX, coords.WorldY - 1, coords.WorldZ));
     if (coords.BlockY < 127)
         predicate(UniversalCoords.FromWorld(coords.WorldX, coords.WorldY + 1, coords.WorldZ));
 }

 protected override double BlockPathWeight(UniversalCoords coords)
 {
     if (this.World.GetBlockId(coords.WorldX, coords.WorldY - 1, coords.WorldZ) == (byte)BlockData.Blocks.Grass)
     {
         return 10.0;
     }
     else
     {
         return this.World.GetBlockLightBrightness(coords) - 0.5; // stay out of lower half of brightness spectrum
     }
 }

 public unsafe byte this[UniversalCoords coords]
 {
     get
     {
         fixed (byte* types = Types)
             return types[coords.BlockPackedCoords];
     }
     set
     {
         fixed (byte* types = Types)
             types[coords.BlockPackedCoords] = value;
     }
 }

 public Chunk this[UniversalCoords coords]
 {
     get
     {
         Chunk chunk;
         Chunks.TryGetValue(coords.ChunkPackedCoords, out chunk);
         return chunk;
     }
     private set
     {
         Chunks.AddOrUpdate(coords.ChunkPackedCoords, value, (key, oldValue) => value);
     }
 }

 public static void Destroy(WorldManager world, UniversalCoords coords)
 {
     PersistentContainer container = Instance(world, coords);
     if (container == null)
         return;
     Chunk chunk = world.GetChunk(coords);
     if (chunk == null)
         return;
     PersistentContainer unused;
     container.Destroy();
     chunk.Containers.TryRemove(container.Coords.BlockPackedCoords, out unused);
     if (container is LargeChestContainer)
         chunk.Containers.TryRemove((container as LargeChestContainer).SecondCoords.BlockPackedCoords, out unused);
 }

 public static void Close(PersistentContainerInterface containerInterface, UniversalCoords coords)
 {
     PersistentContainer container = Instance(containerInterface.World, coords);
     if (container == null)
         return;
     container.RemoveInterface(containerInterface);
     Chunk chunk = container.World.GetChunk(coords);
     if (chunk == null)
         return;
     PersistentContainer unused;
     if (container is LargeChestContainer && container.IsUnused())
     {
         chunk.Containers.TryRemove(container.Coords.BlockPackedCoords, out unused);
         chunk.Containers.TryRemove((container as LargeChestContainer).SecondCoords.BlockPackedCoords, out unused);
     } else if (container is SmallChestContainer && container.IsUnused())
         chunk.Containers.TryRemove(container.Coords.BlockPackedCoords, out unused);
 }

        public static UniversalCoords[] GetDoubleChestCoords(WorldManager world, UniversalCoords coords)
        {
            Chunk chunk = world.GetChunk(coords);
            if (chunk == null || !IsDoubleChest(chunk, coords))
                return null;
            // Is this chest the "North or East", or the "South or West"
            BlockData.Blocks[] nsewBlocks = new BlockData.Blocks[4];
            UniversalCoords[] nsewBlockPositions = new UniversalCoords[4];
            int nsewCount = 0;
            byte? blockId;
            chunk.ForNSEW(coords, uc =>
            {
                blockId = world.GetBlockId(uc) ?? 0;
                nsewBlocks[nsewCount] = (BlockData.Blocks)blockId;
                nsewBlockPositions[nsewCount] = uc;
                nsewCount++;
            });
            UniversalCoords firstCoords;
            UniversalCoords secondCoords;

            if ((byte)nsewBlocks[0] == (byte)BlockData.Blocks.Chest) // North
            {
                firstCoords = nsewBlockPositions[0];
                secondCoords = coords;
            }
            else if ((byte)nsewBlocks[2] == (byte)BlockData.Blocks.Chest) // East
            {
                firstCoords = nsewBlockPositions[2];
                secondCoords = coords;
            }
            else if ((byte)nsewBlocks[1] == (byte)BlockData.Blocks.Chest) // South
            {
                firstCoords = coords;
                secondCoords = nsewBlockPositions[1];
            }
            else// if ((byte)nsewBlocks[3] == (byte)BlockData.Blocks.Chest) // West
            {
                firstCoords = coords;
                secondCoords = nsewBlockPositions[3];
            }
            return new UniversalCoords[] { firstCoords, secondCoords };
        }

        public void GrowCactus(UniversalCoords coords)
        {
            if (GetType(coords) == BlockData.Blocks.Cactus)
                return;

            if (GetType(UniversalCoords.FromWorld(coords.WorldX, coords.WorldY - 3, coords.WorldZ)) == BlockData.Blocks.Cactus)
                return;

            if (!IsNSEWTo(coords, (byte)BlockData.Blocks.Air))
                return;

            if (World.Server.Rand.Next(60) == 0)
            {
                SetType(coords, BlockData.Blocks.Cactus);
            }
        }

        public static Chunk Load(UniversalCoords coords, WorldManager world)
        {
            string path = world.Folder + "/x" + coords.ChunkX + "_z" + coords.ChunkZ + ".gz";

            if (!CanLoad(path))
                return null;

            Stream zip = null;

            Chunk chunk = new Chunk(world, coords);

            try
            {
                zip = new DeflateStream(File.Open(path, FileMode.Open), CompressionMode.Decompress);

                int version = zip.ReadByte();

                switch(version)
                {
                    /* When there's a new mod you do:
                    case 1:
                    {
                     * dosomething
                     * goto case 0;
                    }*/
                    case 0:
                    {
                        chunk.LightToRecalculate = Convert.ToBoolean(zip.ReadByte());
                        chunk.HeightMap = new byte[16,16];
                        int height;
                        chunk.MaxHeight = 0;
                        for (int x = 0; x < 16; ++x)
                        {
                            for (int z = 0; z < 16; ++z)
                            {
                                height = chunk.HeightMap[x, z] = (byte) zip.ReadByte();

                                if (chunk.MaxHeight < height)
                                    chunk.MaxHeight = height;
                            }
                        }
                        chunk.LoadAllBlocks(zip);
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                world.Logger.Log(ex);
                return null;
            }
            if (zip != null)
                zip.Dispose();

            (BlockHelper.Instance((byte) BlockData.Blocks.Sign_Post) as BlockSignBase).LoadSignsFromDisk(chunk, world.SignsFolder);

            return chunk;
        }

 public FurnaceInterface(World.WorldManager world, UniversalCoords coords)
     : base(world, InterfaceType.Furnace, coords, 3)
 {
 }

 public FurnaceInstance(WorldManager world, UniversalCoords coords)
 {
     this.World = world;
     Coords = coords;
 }

 private static void RemoveFurnaceInterface(UniversalCoords coords, FurnaceInterface furnace)
 {
     string id = String.Format("{0}-{1},{2},{3}", furnace.World.Name, coords.WorldX, coords.WorldY, coords.WorldZ);
     lock (_staticLock)
     {
         if (_furnaceInstances.ContainsKey(id))
         {
             _furnaceInstances[id].Remove(furnace);
         }
     }
 }

        /// <summary>
        /// Adds the FurnaceInterface to a FurnaceInstance, then returns the FurnaceInstance it is added to.
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="z"></param>
        /// <param name="furnace"></param>
        /// <returns>The FurnaceInstance that the FurnaceInterface was added to</returns>
        private static FurnaceInstance AddFurnaceInterface(UniversalCoords coords, FurnaceInterface furnace)
        {
            string id = String.Format("{0}-{1},{2},{3}", furnace.World.Name, coords.WorldX, coords.WorldY, coords.WorldZ);
            lock (_staticLock)
            {
                FurnaceInstance furnaceInstance;
                if (!_furnaceInstances.ContainsKey(id))
                {
                    furnaceInstance = new FurnaceInstance(furnace.World, coords);
                    _furnaceInstances[id] = furnaceInstance;
                }
                else
                {
                    furnaceInstance = _furnaceInstances[id];
                }
                furnaceInstance.Add(furnace);

                return furnaceInstance;
            }
        }

 public DispenserInterface(World.WorldManager world, UniversalCoords coords)
     : base(world, InterfaceType.Dispenser, coords, 9)
 {
 }

 public SmallChestInterface(World.WorldManager world, UniversalCoords coords)
     : base(world, InterfaceType.Chest, coords, 27)
 {
 }