public ItemFrameEntity(ItemStack item, ItemFrameDirection direction, Vector3 position)
 {
     Item = item;
     Position = position;
     Direction = direction;
     Pitch = GetRotation(Direction); // This should be Pitch, but it doesn't work. Not sure why.
 }

 protected override ItemStack[] GetDrop(BlockDescriptor descriptor, ItemStack item)
 {
     if (descriptor.Metadata >= 7)
         return new[] { new ItemStack(WheatItem.ItemID), new ItemStack(SeedsItem.ItemID, (sbyte)MathHelper.Random.Next(3)) };
     else
         return new[] { new ItemStack(SeedsItem.ItemID) };
 }

    public static void addToInventory(int itemID, string pathToIcon)
    {
        itemHUD_Controls hud = GameObject.Find ("ItemHUD").GetComponent<itemHUD_Controls>();

        for(int i = 0; i < maxInventorySize; i++) {
            if(inv[i] == null) {
                inv[i] = new ItemStack(itemID, pathToIcon);

                //Update Icon in Inventory HUD
                hud.items[i].GetComponent<Image> ().sprite = Resources.Load<Sprite> (pathToIcon);
                hud.items[i].GetComponent<Image> ().color = new Color32(255, 255, 255, 255);
                inv[i].incrementStack();
                //Update stack counter
                hud.items[i].GetComponentInChildren<Text>().text = getSlotStackSize(i).ToString();
                Resources.UnloadUnusedAssets();

                break;
            } else {
                if(inv[i].getItemID() == itemID && !inv[i].checkStackFull()) {
                    inv[i].incrementStack();
                    hud.items[i].GetComponentInChildren<Text>().text = getSlotStackSize(i).ToString();
                    break;
                }
            }
        }
    }

 public override void Click(Entity entity, ItemStack item)
 {
     if (!(entity is PlayerEntity))
     {
         // TODO: non-player support
         return;
     }
     PlayerEntity player = (PlayerEntity)entity;
     Location eye = player.GetEyePosition();
     Location forw = player.ForwardVector();
     RayCastResult rcr;
     bool h = player.TheRegion.SpecialCaseRayTrace(eye, forw, 5, MaterialSolidity.ANY, player.IgnoreThis, out rcr);
     if (h)
     {
         if (rcr.HitObject != null && rcr.HitObject is EntityCollidable && ((EntityCollidable)rcr.HitObject).Entity != null)
         {
             // TODO: ???
         }
         else if (player.Mode.GetDetails().CanPlace)
         {
             Location block = (new Location(rcr.HitData.Location) - new Location(rcr.HitData.Normal).Normalize() * 0.01).GetBlockLocation();
             block = block.GetBlockLocation();
             BlockInternal blockdat = player.TheRegion.GetBlockInternal(block);
             Material mat = (Material)blockdat.BlockMaterial;
             if (mat != Material.AIR)
             {
                 int paint = item.Datum;
                 player.TheRegion.SetBlockMaterial(block, mat, blockdat.BlockData, (byte)paint, (byte)(blockdat.BlockLocalData | (byte)BlockFlags.EDITED), blockdat.Damage);
             }
         }
     }
 }

 public override void ItemUsedOnBlock(Coordinates3D coordinates, ItemStack item, BlockFace face, IWorld world, IRemoteClient user)
 {
     var bottom = coordinates + MathHelper.BlockFaceToCoordinates(face);
     var top = bottom + Coordinates3D.Up;
     if (world.GetBlockID(top) != 0 || world.GetBlockID(bottom) != 0)
         return;
     DoorFlags direction;
     switch (MathHelper.DirectionByRotationFlat(user.Entity.Yaw))
     {
         case Direction.North:
             direction = DoorFlags.Northwest;
             break;
         case Direction.South:
             direction = DoorFlags.Southeast;
             break;
         case Direction.East:
             direction = DoorFlags.Northeast;
             break;
         default: // Direction.West:
             direction = DoorFlags.Southwest;
             break;
     }
     user.Server.BlockUpdatesEnabled = false;
     world.SetBlockID(bottom, BlockID);
     world.SetMetadata(bottom, (byte)direction);
     world.SetBlockID(top, BlockID);
     world.SetMetadata(top, (byte)(direction | DoorFlags.Upper));
     user.Server.BlockUpdatesEnabled = true;
     item.Count--;
     user.Inventory[user.SelectedSlot] = item;
 }

 public void AddPart(ItemStack IS)
 {
     if (!Parts.Contains(IS))
     {
         Parts.Add(IS);
     }
 }

 public void Split(ItemStack stack) {
     var nStack = stack.Split();
     if (nStack != null) {
         if (!AddNewStack(nStack))
             DropStack(nStack);
     }
 }

        public BinderItem(ItemValue itemValue)
        {
            bindItemData(DataItem.getItemDataByItemValue(itemValue));

            itemStack = createItemStack(DataItem.getItemDataByItemValue(itemValue), itemValue);
            bindItemValue(itemValue);
        }

 private void Awake() {
     baseScript = GetComponent<SimpleObject>();
     if(drop == null) {
         ItemEntities.Init();
         drop = new ItemStack(ItemEntities.items.Values.First());
     }
 }

 public override void Click(Entity entity, ItemStack item)
 {
     // TODO: Should non-players be allowed here?
     if (!(entity is PlayerEntity))
     {
         return;
     }
     PlayerEntity player = (PlayerEntity)entity;
     // TODO: Generic 'player.gettargetblock'?
     Location eye = player.GetEyePosition();
     Location forw = player.ForwardVector();
     RayCastResult rcr;
     bool h = player.TheRegion.SpecialCaseRayTrace(eye, forw, 5, MaterialSolidity.ANY, player.IgnoreThis, out rcr);
     if (h)
     {
         if (rcr.HitObject != null && rcr.HitObject is EntityCollidable && ((EntityCollidable)rcr.HitObject).Entity != null)
         {
             // TODO: ???
         }
         else
         {
             Location block = (new Location(rcr.HitData.Location) - new Location(rcr.HitData.Normal).Normalize() * 0.01).GetBlockLocation();
             Material mat = player.TheRegion.GetBlockMaterial(block);
             if (mat != Material.AIR)
             {
                 player.Selection = new AABB() { Min = block, Max = block + Location.One };
                 player.NetworkSelection();
             }
         }
     }
 }

 public override void ItemUsedOnBlock(Coordinates3D coordinates, ItemStack item, BlockFace face, IWorld world, IRemoteClient user)
 {
     coordinates += MathHelper.BlockFaceToCoordinates(face);
     var descriptor = world.GetBlockData(coordinates);
     LadderDirection direction;
     switch (MathHelper.DirectionByRotationFlat(user.Entity.Yaw))
     {
         case Direction.North:
             direction = LadderDirection.North;
             break;
         case Direction.South:
             direction = LadderDirection.South;
             break;
         case Direction.East:
             direction = LadderDirection.East;
             break;
         default:
             direction = LadderDirection.West;
             break;
     }
     descriptor.Metadata = (byte)direction;
     if (IsSupported(descriptor, user.Server, world))
     {
         world.SetBlockID(descriptor.Coordinates, BlockID);
         world.SetMetadata(descriptor.Coordinates, (byte)direction);
         item.Count--;
         user.Inventory[user.SelectedSlot] = item;
     }
 }

 public override bool GetDrop(ToolItem tool, out ItemStack[] drop)
 {
     drop = new ItemStack[0];
     if (tool is ShovelItem)
         drop = new[] { new ItemStack(new SnowballItem(), 1) };
     return tool is ShovelItem;
 }

 public override void Click(Entity entity, ItemStack item)
 {
     if (!(entity is PlayerEntity))
     {
         return; // TODO: non-player support?
     }
     PlayerEntity player = (PlayerEntity)entity;
     if (player.Manipulator_Grabbed != null)
     {
         return;
     }
     Location eye = player.GetEyePosition();
     CollisionResult cr = player.TheRegion.Collision.RayTrace(eye, eye + player.ForwardVector() * 50, player.IgnoreThis);
     if (!cr.Hit || cr.HitEnt == null || cr.HitEnt.Mass <= 0)
     {
         return;
     }
     PhysicsEntity target = (PhysicsEntity)cr.HitEnt.Tag;
     player.Manipulator_Grabbed = target;
     player.Manipulator_Distance = (double)(eye - target.GetPosition()).Length();
     player.Manipulator_Beam = new ConnectorBeam() { type = BeamType.MULTICURVE };
     player.Manipulator_Beam.One = player;
     player.Manipulator_Beam.Two = target;
     player.Manipulator_Beam.color = Colors.BLUE;
     player.TheRegion.AddJoint(player.Manipulator_Beam);
 }

        public void GenerateDropEntity(BlockDescriptor descriptor, IWorld world, IMultiplayerServer server, ItemStack item)
        {
            var entityManager = server.GetEntityManagerForWorld(world);
            var items = new ItemStack[0];
            var type = ToolType.None;
            var material = ToolMaterial.None;
            var held = ItemRepository.GetItemProvider(item.ID);

            if (held is ToolItem)
            {
                var tool = held as ToolItem;
                material = tool.Material;
                type = tool.ToolType;
            }

            if ((EffectiveTools & type) > 0)
            {
                if ((EffectiveToolMaterials & material) > 0)
                    items = GetDrop(descriptor, item);
            }

            foreach (var i in items)
            {
                if (i.Empty) continue;
                var entity = new ItemEntity(new Vector3(descriptor.Coordinates) + new Vector3(0.5), i);
                entityManager.SpawnEntity(entity);
            }
        }

 public override void Click(Entity entity, ItemStack item)
 {
     if (!(entity is CharacterEntity))
     {
         // TODO: Non-character support?
         return;
     }
     CharacterEntity character = (CharacterEntity)entity;
     double range = RangeBase * item.GetAttributeF("range_mod", 1f);
     double strength = StrengthBase * item.GetAttributeF("strength_mod", 1f) * GetStrength();
     Location start = character.GetEyePosition(); // TODO: ItemPosition?
     Location forw = character.ForwardVector();
     Location mid = start + forw * range;
     // TODO: base the pull on extent of the entity rather than its center. IE, if the side of a big ent is targeted, it should be rotated by the force.
     List<Entity> ents = character.TheRegion.GetEntitiesInRadius(mid, range);
     foreach (Entity ent in ents)
     {
         if (ent is PhysicsEntity) // TODO: Support for primitive ents?
         {
             PhysicsEntity pent = (PhysicsEntity)ent;
             Location rel = (start - ent.GetPosition());
             double distsq = rel.LengthSquared();
             if (distsq < 1)
             {
                 distsq = 1;
             }
             pent.ApplyForce((rel / distsq) * strength);
         }
     }
 }

 public void InitItem(ItemStack itemStack) {
     GetComponent<Image>().sprite = itemStack.TypeItem.Icon;
     Count.text = itemStack.Count.ToString();
     currentItemStack = itemStack;
     itemStack.OnChangeCount += ChangeCount;
     itemStack.OnNullCount += Delete;
 }

    // Use this for initialization
    void Start()
    {
        _descriptors = new ItemDescriptors();
        _descriptors.Initialize();

        // TODO: Hook Descriptors

        StorageContainer sc = new StorageContainer();
        Storage s = (Storage)_descriptors.Find("Backpack").Create();

        // Add the Storage to our StorageContainer
        sc.Storages.Add(s);

        ItemStack stack = new ItemStack(_descriptors.Find("Whiskey Bottle"), s);
        stack.AddQuantity(80);
        // Automatically add the Stack to the first available storage of the Container.
        sc.AddStack(stack);

        stack = new ItemStack(_descriptors.Find("Botan"));
        stack.AddQuantity(1);
        // Automatically add the Stack to the first available storage of the Container.
        sc.AddStack(stack);

        foreach (IStorage storage in sc.Storages)
        {
            string msg = "";
            msg += "Total Storage weight: " + storage.Weight / 1000.0f + "kg, Content Weight: " + System.Math.Round(storage.ContentWeight / 1000.0f, 2) + "/" + storage.Capacity / 1000.0f + "kg\n";
            foreach (IItemStack itemStack in storage.Stacks)
            {
                msg += itemStack.Quantity + "x " + itemStack.Descriptor.Name + " (" + itemStack.Weight / 1000.0f + "kg)\n";
            }
            Debug.Log(msg);
        }
    }

 public override void ReleaseAltClick(Entity entity, ItemStack item)
 {
     // TODO: Handle non-players
     if (!(entity is PlayerEntity))
     {
         return;
     }
     PlayerEntity player = (PlayerEntity)entity;
     if (player.TheRegion.GlobalTickTime - player.LastGunShot < fireRate)
     {
         return;
     }
     player.LastGunShot = player.TheRegion.GlobalTickTime;
     for (int i = 1; i < player.Breadcrumbs.Count; i++)
     {
         if ((player.GetPosition() - player.Breadcrumbs[i]).LengthSquared() < 4)
         {
             player.Breadcrumbs.RemoveRange(i, player.Breadcrumbs.Count - i);
         }
     }
     List<Location> locs = new List<Location>();
     Location cpos = player.GetPosition();
     for (int i = player.Breadcrumbs.Count - 1; i >= 0; i--)
     {
         if ((player.Breadcrumbs[i] - cpos).LengthSquared() > MaxRadius * MaxRadius)
         {
             break;
         }
         locs.Add(player.Breadcrumbs[i]);
     }
     if (locs.Count > 0)
     {
         player.Network.SendPacket(new PathPacketOut(locs));
     }
 }

 public override bool onItemUse(ItemStack itemstack, EntityPlayer entityplayer, World world, int i, int j, int k,
     int l)
 {
     if (l == 0)
     {
         return false;
     }
     if (l == 1)
     {
         return false;
     }
     byte byte0 = 0;
     if (l == 4)
     {
         byte0 = 1;
     }
     if (l == 3)
     {
         byte0 = 2;
     }
     if (l == 5)
     {
         byte0 = 3;
     }
     var entitypainting = new EntityPainting(world, i, j, k, byte0);
     if (entitypainting.onValidSurface())
     {
         if (!world.singleplayerWorld)
         {
             world.entityJoinedWorld(entitypainting);
         }
         itemstack.stackSize--;
     }
     return true;
 }

        public override void ItemUsedOnBlock(Coordinates3D coordinates, ItemStack item, BlockFace face, IWorld world, IRemoteClient user)
        {
            if (face == BlockFace.PositiveY || face == BlockFace.NegativeY)
            {
                // Trapdoors are not placed when the user clicks on the top or bottom of a block
                return;
            }

            // NOTE: These directions are rotated by 90 degrees so that the hinge of the trapdoor is placed
            // where the user had their cursor.
            switch (face)
            {
                case BlockFace.NegativeZ:
                    item.Metadata = (byte)TrapdoorDirection.West;
                    break;
                case BlockFace.PositiveZ:
                    item.Metadata = (byte)TrapdoorDirection.East;
                    break;
                case BlockFace.NegativeX:
                    item.Metadata = (byte)TrapdoorDirection.South;
                    break;
                case BlockFace.PositiveX:
                    item.Metadata = (byte)TrapdoorDirection.North;
                    break;
                default:
                    return;
            }

            base.ItemUsedOnBlock(coordinates, item, face, world, user);
        }