/// <summary>
    /// Raycasts from the mouse
    /// returns true if something was hit
    /// 
    /// uses out to return relevant menu scripts
    /// 
    /// </summary>
    /// <param name="hitInfo"></param>
    /// <param name="items"></param>
    /// <param name="itemSlots"></param>
    /// <returns></returns>
    public bool Raycast(out RaycastHit[] hitInfo, out Item[] items, out ItemSlot[] itemSlots)
    {
        items = new Item[0];
        itemSlots = new ItemSlot[0];
        hitInfo = Physics.RaycastAll (m_MainCamera.ScreenPointToRay (Input.mousePosition), RAYCAST_DISTANCE, m_RaycastMask.value);
        Debug.DrawLine (m_MainCamera.ScreenPointToRay(Input.mousePosition).origin, m_MainCamera.ScreenPointToRay(Input.mousePosition).origin + (m_MainCamera.ScreenPointToRay(Input.mousePosition).direction * RAYCAST_DISTANCE), Color.black, 1.0f);

        if(hitInfo.Length > 0)
        {//hit at least one menu thing
            List<Item> itemsFound = new List<Item>();
            List<ItemSlot> itemSlotsFound = new List<ItemSlot>();

            for(int i = 0; i < hitInfo.Length; i++)
            {
                Item item = hitInfo[i].collider.gameObject.GetComponent<Item>();
                if (item != null)
                    itemsFound.Add(item);

                ItemSlot itemSlot = hitInfo[i].collider.gameObject.GetComponent<ItemSlot>();
                if (itemSlot != null)
                    itemSlotsFound.Add(itemSlot);
            }

            items = itemsFound.ToArray();
            itemSlots = itemSlotsFound.ToArray();

            return true;
        }
        return false;
    }

        /// <summary>
        /// Отрисовка предмета в инвентаре
        /// </summary>
        /// <param name="item">Рисуемый предмет</param>
        /// <param name="offsetX">Смещение (позиция) инвентаря по x</param>
        /// <param name="offsetY">Смещение (позиция) инвентаря по y</param>
        /// <param name="fixWebPosition">при fixWebPosition=true предмет рисуется "в сетке"</param>
        /// <param name="drawIcon">при drawIcon=false, предмет рисуется без иконки</param>
        public void DrawItem(ItemSlot item, float offsetX, float offsetY, bool fixWebPosition = true, bool drawIcon = true)
        {
            Rect cellRectangle;

            if (fixWebPosition) {

                cellRectangle = new Rect(offsetX + CellSettings.cellPaddingX + (item.position.X - 1) * CellSettings.cellWidth+shadowSize,
                                         offsetY + CellSettings.cellPaddingY + (item.position.Y - 1) * CellSettings.cellHeight+shadowSize,
                                         CellSettings.cellWidth,
                                         CellSettings.cellHeight);

            } else {

                cellRectangle = new Rect(offsetX+shadowSize,
                                         offsetY+shadowSize,
                                         CellSettings.cellWidth,
                                         CellSettings.cellHeight);

            }

            string description = item.item.getCount()>1? item.item.getCount().ToString()+CLang.getInstance().get(Dictionary.K_COUNT) : "";

            GUI.Box(cellRectangle, description, labelShadow);

            cellRectangle.x-=shadowSize;
            cellRectangle.y-=shadowSize;

            if (drawIcon)
                labelStyle.normal.background = item.item.resource.icon;

            GUI.color = new Color(1f,1f,1f,1f);
            GUI.Box(cellRectangle, description, labelStyle);
        }

        public CraftingGrid(GameWorld GameWorld, Vector2 Position)
        {
            this.Position = Position;
            RecipePartIdMatching = new int[5, 5];

            for (int y = 0; y < 5; y++)
            {
                for (int x = 0; x < 5; x++)
                {
                    RecipeSlots[x, y] = new ItemSlot(GameWorld);
                    RecipeSlots[x, y].Visible = true;
                    Vector2 UpperLeftPos = Position + new Vector2(x * 34, y * 34);
                    RecipeSlots[x, y].Position = new Rectangle((int)UpperLeftPos.X, (int)UpperLeftPos.Y, 32, 32);
                    RecipeSlots[x, y].OnStackModified += UpdateGrid;
                    RecipePartIdMatching[x, y] = -1;
                }
            }

            OutputSlot = new ItemSlot(GameWorld);
            OutputSlot.Visible = true;
            OutputSlot.State = ItemSlot.SlotState.InputLocked;
            OutputSlot.Position = new Rectangle((int)Position.X + 5 * 32 + 10, (int)Position.Y + 2 * 32, 32, 32);

            OutputSlot.OnStackModified += ItemCrafted;
        }

    public static void SwapItemsNoReAdding(ItemSlot slot1, ItemSlot slot2)
    {
        Item tempItem = slot1.getItem();
        slot1.m_Item = slot2.getItem();
        slot2.m_Item = tempItem;

        slot1.getItem().OnMount(slot1);
        slot2.getItem().OnMount(slot2);
    }

        public void DrawCellsItem(float offsetX, float offsetY, ItemSlot item, Texture2D image)
        {
            Rect cellRect = new Rect();

            cellRect.x = offsetX + (item.getPosition().X - 1) * CellSettings.cellWidth + CellSettings.cellPaddingX;
            cellRect.y = offsetY + (item.getPosition().Y - 1) * CellSettings.cellHeight + CellSettings.cellPaddingY;
            cellRect.width = CellSettings.cellWidth * item.item.getSize().getWidth();
            cellRect.height = CellSettings.cellHeight * item.item.getSize().getHeight();

            GUI.DrawTextureWithTexCoords(cellRect, image, textCoords);
        }

	public void Swap (ItemSlot other) {
		if (!CanSwap (other))
			return;

		var swapper = other.currentItem;
		other.currentItem = currentItem;
		currentItem = swapper;

		RestoreItem ();
		other.RestoreItem ();
	}

 public EquipmentItem SetItem(ItemSlot slot, EquipmentItem item)
 {
     if (!(item is EquipmentItem))
         return null;
     var eqItem = item as EquipmentItem;
     if (eqItem.RequiredSpecialisation != Specialisation.NONE
         && eqItem.RequiredSpecialisation != this.Specialisation)
         return null;
     EquipmentItem oldItem = null;
     if (Items.ContainsKey(slot))
         oldItem = Items[slot];
     Items[slot] = eqItem;
     return oldItem;
 }

	/// <summary>
	/// C'tor
	/// </summary>
	/// <param name="_slotsData">Data about slot: slot key && available item types for the slot</param>
	/// <param name="onEquipmentUpdate"></param>
	public UnitInventory(Dictionary<EUnitEqupmentSlot, EItemType[]> _slotsData, ArrayRO<ItemSlot> _initialItems, Action<EUnitEqupmentSlot, EItemKey, EItemKey> onEquipmentUpdate) {
		_slotsConfig = _slotsData;

		_equipment = new ItemSlot[_slotsConfig.Count];
		int i = 0;
		foreach(KeyValuePair<EUnitEqupmentSlot, EItemType[]> kvp in _slotsConfig) {
			_equipment[i] = new ItemSlot(kvp.Key, EItemKey.None);
			i++;
		}

		for (i = 0; i < _initialItems.Length; i++) {
			Equip(_initialItems[i].SlotName, _initialItems[i].ItemKey);
		}

		_onEquipmentUpdate = onEquipmentUpdate;
	}

	public void Show(ItemSlot itemSlot)
	{

		Vector3 pos = Input.mousePosition;

		pos.x = Mathf.Clamp01(pos.x / Screen.width);
		pos.y = Mathf.Clamp01(pos.y / Screen.height);

		if(_tempRightClick == null)
		{
			_itemSlot = itemSlot;
			_tempRightClick = NGUITools.AddChild(this.gameObject.transform.parent.gameObject, RightClickPrefab);
			_tempRightClick.transform.position = _camera.ViewportToWorldPoint(pos);
			RightClickMaker m = _tempRightClick.GetComponent<RightClickMaker>();
			m.Make(_itemSlot);
		}
	}

        private void SetItemInSlot(Item value, ItemSlot slot)
        {
            if (!CanEquip(value, slot))
                return;
            
            var old = Equip.FirstOrDefault(i => i.Slot == slot);
            if (old != null)
            {
                Equip.Remove(old);
                old.Slot = ItemSlot.Unequipable;
            }

            if (value != null)
            {
                value.Slot = slot;
                Equip.Add(value);
            }
            OnPropertyChanged(slot.ToString());
            RefreshItemAttributes();
        }

    // Reader
    public static object JsonDeserializer(Jboy.JsonReader reader)
    {
        if(reader.TryReadNull())
            return null;

        var itemSlot = new ItemSlot();

        reader.ReadObjectStart();

        // ID
        reader.ReadPropertyName("item");
        itemSlot.item = Jboy.Json.ReadObject<Item>(reader);

        // Count
        reader.ReadPropertyName("count");
        itemSlot.count = (ulong)reader.ReadNumber();

        reader.ReadObjectEnd();

        return itemSlot;
    }

	void SetEquipStatus(ItemSlot itemSlot)
	{

		var type = itemSlot.GetType();

		if(type == typeof(StorageSlot))
		{
			EquipButton.SetActive(true);
			UnequipButton.SetActive(false);
		}
		else if(type == typeof(EquipmentSlot))
		{
			EquipButton.SetActive(false);
			UnequipButton.SetActive(true);
		}
		else
		{
			EquipButton.SetActive(false);
			UnequipButton.SetActive(true);
		}
	}

	public void Make(ItemSlot itemSlot)
	{
		Item item = itemSlot.item;

		SetStackable(item);

		switch(item.Type)
		{
		case ItemType.Armor:
			SetArmorButtons(itemSlot);
			break;
		case ItemType.Consumable:
			SetConsumable(itemSlot);
			break;
		case ItemType.Enhancer:
			SetEnhancer(itemSlot);
			break;
		case ItemType.Generator:
			SetGenerator(itemSlot);
			break;
		case ItemType.LaserWeapon:
			SetLaserWeapon(itemSlot);
			break;
		case ItemType.LegacyWeapon:
			SetLegacyWeapon(itemSlot);
			break;
		case ItemType.MagneticWeapon:
			SetMagneticWeapon(itemSlot);
			break;
		case ItemType.Melee:
			SetMelee(itemSlot);
			break;
		case ItemType.Misc:
			SetMisc(itemSlot);
			break;
		case ItemType.Quest:
			SetQuest(itemSlot);
			break;
		}
	}

 public ushort GetEquippedBySlot(ItemSlot slot)
 {
     Equip eqp;
     if (EquippedItems.TryGetValue(slot, out eqp))
     {
         return eqp.ItemID;
     }
     else return ushort.MaxValue;
 }

 // called by engine
 void RaiseSmthMoveItem(Critter from_cr, Item item, ItemSlot from_slot)
 {
     if (SmthMoveItem != null)
         SmthMoveItem(this, new CritterSmthMoveItemEventArgs(this, from_cr, item, from_slot));
 }

 public CritterSmthMoveItemEventArgs(Critter cr, Critter from_cr, Item item, ItemSlot from_slot)
     : base(cr, item, from_slot)
 {
     this.From = from_cr;
 }

 public CritterMoveItemEventArgs(Critter cr, Item item, ItemSlot from_slot)
     : base(cr)
 {
     this.Item = item;
     this.FromSlot = from_slot;
 }

        private void UpdateGraphEquipped(string subgraph)
        {
            SetGraphControl(ComparisonGraph);
            CGL_Legend.LegendItems = Calculations.SubPointNameColors;
            ComparisonGraph.LegendItems = Calculations.SubPointNameColors;
            ComparisonGraph.Mode = ComparisonGraph.DisplayMode.Subpoints;
            List<ComparisonCalculationBase> itemCalculations = new List<ComparisonCalculationBase>();

            if (subgraph == "Gear" || subgraph == "All")
            {
                CharacterSlot[] slots = new CharacterSlot[]
                {
                     CharacterSlot.Back, CharacterSlot.Chest, CharacterSlot.Feet, CharacterSlot.Finger1,
                     CharacterSlot.Finger2, CharacterSlot.Hands, CharacterSlot.Head, CharacterSlot.Legs,
                     CharacterSlot.MainHand, CharacterSlot.Neck, CharacterSlot.OffHand, /*CharacterSlot.Projectile,
                     CharacterSlot.ProjectileBag,*/ CharacterSlot.Ranged, CharacterSlot.Shoulders,
                     CharacterSlot.Trinket1, CharacterSlot.Trinket2, CharacterSlot.Waist, CharacterSlot.Wrist
                };
                foreach (CharacterSlot slot in slots)
                {
                    ItemInstance item = Character[slot];
                    if (item != null)
                    {
                        itemCalculations.Add(Calculations.GetItemCalculations(item, Character, slot));
                    }
                }
            }
            if (subgraph == "Enchants" || subgraph == "All")
            {
                ItemSlot[] slots = new ItemSlot[]
                {
                     ItemSlot.Back, ItemSlot.Chest, ItemSlot.Feet, ItemSlot.Finger,
                     ItemSlot.Hands, ItemSlot.Head, ItemSlot.Legs,
                     ItemSlot.MainHand, ItemSlot.OffHand, ItemSlot.Ranged, ItemSlot.Shoulders,
                     ItemSlot.Waist, ItemSlot.Wrist
                };
                
                foreach (ItemSlot slot in slots)
                    foreach (ComparisonCalculationBase calc in Calculations.GetEnchantCalculations(slot, Character, Calculations.GetCharacterCalculations(Character), true))
                        itemCalculations.Add(calc);
            }
            if (subgraph == "Tinkerings" || subgraph == "All")
            {
                ItemSlot[] slots = new ItemSlot[]
                {
                     ItemSlot.Back, ItemSlot.Hands, ItemSlot.Waist,
                };
                foreach (ItemSlot slot in slots)
                    foreach (ComparisonCalculationBase calc in Calculations.GetTinkeringCalculations(slot, Character, Calculations.GetCharacterCalculations(Character), true))
                        itemCalculations.Add(calc);
            }
            if (subgraph == "Buffs" || subgraph == "All")
            {
                itemCalculations.AddRange(Calculations.GetBuffCalculations(Character, Calculations.GetCharacterCalculations(Character), ConvertBuffSelector("Current")));
                ComparisonGraph.DisplayCalcs(itemCalculations.ToArray());
            }
            // Now Push the results to the screen
            ComparisonGraph.DisplayCalcs(_itemCalculations = itemCalculations.ToArray());
        }

 private static int SlotIndex(ItemSlot slot)
 {
     switch (slot)
     {
         case ItemSlot.Head:
         case ItemSlot.Chest:
         case ItemSlot.Legs:
         case ItemSlot.TwoHand:
             return 0;
         case ItemSlot.Shoulders:
         case ItemSlot.Hands:
         case ItemSlot.Waist:
         case ItemSlot.Feet:
             return 1;
         case ItemSlot.Wrist:
         case ItemSlot.Neck:
         case ItemSlot.Back:
         case ItemSlot.Finger:
         case ItemSlot.OffHand:
         default:
             return 2;
         case ItemSlot.MainHand:
         case ItemSlot.OneHand:
             return 3;
         case ItemSlot.Ranged:
             return 4;
     }
 }

    public CommandSet AddCommandSet(string name, int capacity, bool autoFire, E_CommandConsume consumeType, CommandSet pipe)
    {
        CommandSet ret = null;
        if (consumeType == E_CommandConsume.ItemSlot)
        {
            ret = new ItemSlot(name, pipe);
        }
        else if (consumeType == E_CommandConsume.None)
        {
            ret = new ConsumableCommandSet(capacity, autoFire, false, pipe);
        }
        else if (consumeType == E_CommandConsume.Skill)
        {
            ret = new SkillSlot(pipe);
        }

        if (ret != null)
        {
            commandQueue.Add(name, ret);
        }
        return ret;
    }