/// <summary>
        /// not used in this game
        /// </summary>
        /// <param name="slot"></param>
        /// <returns></returns>
        public bool CanBeEquippedInSlot(EquipmentSlot slot)
        {
            if (slot == EquipmentSlot.RightHand)
                return true;

            return false;
        }

 /// <summary>
 /// When overridden in the derived class, notifies the owner of this object instance
 /// that an equipment slot has changed.
 /// </summary>
 /// <param name="slot">The slot that changed.</param>
 /// <param name="graphicIndex">The new graphic index of the slot.</param>
 protected override void SendSlotUpdate(EquipmentSlot slot, GrhIndex? graphicIndex)
 {
     using (var msg = ServerPacket.UpdateEquipmentSlot(slot, graphicIndex))
     {
         User.Send(msg, ServerMessageType.GUIItems);
     }
 }

        void CreateItemSlots(int row, int column, EquipmentSlot slot)
        {
            var loc = new Vector2(row, column);
            var pos = _itemSize * loc;

            new EquippedItemPB(this, pos, slot);
        }

        /// <summary>
        /// not used in this game
        /// </summary>
        /// <param name="slot"></param>
        /// <returns></returns>
        public bool CanBeEquippedInSlot(EquipmentSlot slot)
        {
            if (slot == EquipmentSlot.Weapon)
                return true;

            return false;
        }

        public ISWeapon()
        {
            _minDamage = 0;
            _durability = 1;
            _maxDurability = 100;

            equipmentSlot = EquipmentSlot.Hands;
        }

        public ISArmor()
        {
            _curArmor = 0;
            _maxArmor = 100;
            _durability = 1;
            _maxDurability = 100;

            equipmentSlot = EquipmentSlot.Torso;
        }

        public ISWeapon()
        {
            _minDamage = 0;
            _durability = 1;
            _maxDurability = 1;
            _prefab = null;

            equipmentSlot = EquipmentSlot.Weapon;
        }

 private void EquipItem(EquipmentSlot part, int uid)
 {
     if (!IsEmpty(part))
         // Uh oh we are confused about something! But it's better to just do what the server says
     {
         UnEquipItem(part);
     }
     EquippedEntities.Add(part, Owner.EntityManager.GetEntity(uid));
 }

        public ISArmor()
        {
            _curArmor = 0;
            _maxArmor = 0;
            _durability = 1;
            _maxDurability = 1;

            equipmentSlot = EquipmentSlot.Chest;
        }

        // TODO: remove method
        public Item Get(EquipmentSlot slot)
        {
            Item result;
                        if (TryGet(slot, out result))
                        {
                                return result;
                        }

                        return null;
        }

        public override void SetParameter(ComponentParameter parameter)
        {
            base.SetParameter(parameter);

            switch (parameter.MemberName)
            {
                case "wearloc":
                    wearloc = (EquipmentSlot) Enum.Parse(typeof (EquipmentSlot), parameter.GetValue<string>());
                    break;
            }
        }

        /// <summary>
        /// Returns a default item that can be equipped to the given slot
        /// </summary>
        public ItemTemplate GetDefault(EquipmentSlot slot)
        {
            var template = m_defaultItemTemplates[(int)slot];
            if (template == null)
            {
                Setup.EnsureItemsLoaded();
                foreach (var temp in ItemMgr.Templates)
                {
                    if (temp != null && temp.EquipmentSlots.Contains(slot))
                    {
                        m_defaultItemTemplates[(int)slot] = template = temp;
                    }
                }
            }

            Assert.IsNotNull(template);
            return template;
        }

    private void SetCharacter()
    {
        //are we looking for player or npc?
        if (CharacterID == 0)
        {
            GameObject player = GameObject.Find("Player");

            if (player != null)
            {
                Transform childPart = player.transform.FindChild(slotName);

                if (childPart != null)
                {
                    equipmentSlot = childPart.GetComponent<EquipmentSlot>();
                }
            }
        }
        //TODO (Jukki) NPC previews? Party members
    }

 private void EquippedBy(int uid, EquipmentSlot wearloc)
 {
     Owner.SendMessage(this, ComponentMessageType.ItemEquipped);
     Owner.AddComponent(ComponentFamily.Mover,
                        Owner.EntityManager.ComponentFactory.GetComponent("SlaveMoverComponent"));
     Owner.SendMessage(this, ComponentMessageType.SlaveAttach, uid);
     switch (wearloc)
     {
         case EquipmentSlot.Back:
             SendDrawDepth(DrawDepth.MobOverAccessoryLayer);
             break;
         case EquipmentSlot.Belt:
             SendDrawDepth(DrawDepth.MobUnderAccessoryLayer);
             break;
         case EquipmentSlot.Ears:
             SendDrawDepth(DrawDepth.MobUnderAccessoryLayer);
             break;
         case EquipmentSlot.Eyes:
             SendDrawDepth(DrawDepth.MobUnderAccessoryLayer);
             break;
         case EquipmentSlot.Feet:
             SendDrawDepth(DrawDepth.MobUnderClothingLayer);
             break;
         case EquipmentSlot.Hands:
             SendDrawDepth(DrawDepth.MobOverAccessoryLayer);
             break;
         case EquipmentSlot.Head:
             SendDrawDepth(DrawDepth.MobOverClothingLayer);
             break;
         case EquipmentSlot.Inner:
             SendDrawDepth(DrawDepth.MobUnderClothingLayer);
             break;
         case EquipmentSlot.Mask:
             SendDrawDepth(DrawDepth.MobUnderAccessoryLayer);
             break;
         case EquipmentSlot.Outer:
             SendDrawDepth(DrawDepth.MobOverClothingLayer);
             break;
     }
 }

        public EquipmentSlotUi(EquipmentSlot slot, IPlayerManager playerManager, IResourceManager resourceManager,
                               IUserInterfaceManager userInterfaceManager)
        {
            _playerManager = playerManager;
            _resourceManager = resourceManager;
            _userInterfaceManager = userInterfaceManager;

            _color = Color.White;

            AssignedSlot = slot;
            _buttonSprite = _resourceManager.GetSprite("slot");
            _textSprite = new TextSprite(slot + "UIElementSlot", slot.ToString(),
                                         _resourceManager.GetFont("CALIBRI"))
                              {
                                  ShadowColor = Color.Black,
                                  ShadowOffset = new Vector2D(1, 1),
                                  Shadowed = true,
                                  Color = Color.White
                              };

            Update(0);
        }

    void HandleHand(EquipmentSlot slot, bool down, bool interact)
    {
        if (slot.occupied) {
            var item = slot.item;
            if (down && interact && item.CanUnequip(slot)) {
                slot.Unequip();
                item.OnDrop();
                item.GetComponent<Rigidbody>().AddForce(
                    (Vector3.up + _camera.transform.forward) * 200.0f);
            }
        } else if (down) {
            Item highlightedItem = null;

            var pos = slot.attachment.transform.position;
            var distance = pickupRange;
            var colliders = Physics.OverlapSphere(pos, pickupRange);

            foreach (var col in colliders) {
                var item = col.GetComponentInParent<Item>();
                if ((item == null) || item.equipped ||
                    !item.CanEquip(slot)) continue;

                var dis = Vector3.Distance(pos, col.ClosestPointOnBounds(pos));
                if (dis <= distance) {
                    highlightedItem = item;
                    distance = dis;
                }
            }

            if (highlightedItem != null) {
                highlightedItem.highlighted = true;

                if (interact) {
                    highlightedItem.OnPickup();
                    slot.Equip(highlightedItem);
                }
            }
        }
    }

 /// <summary>
 /// Initializes a new instance of the <see cref="CharacterEquippedTable"/> class.
 /// </summary>
 /// <param name="characterID">The initial value for the corresponding property.</param>
 /// <param name="itemID">The initial value for the corresponding property.</param>
 /// <param name="slot">The initial value for the corresponding property.</param>
 public CharacterEquippedTable(CharacterID @characterID, ItemID @itemID, EquipmentSlot @slot)
 {
     CharacterID = @characterID;
     ItemID = @itemID;
     Slot = @slot;
 }

		/// <summary>
		/// For all things that depend on info of all spells from first Init-round and other things
		/// </summary>
		internal void Init2()
		{
			if (inited)
			{
				return;
			}
			inited = true;

            IsChanneled = AttributesEx.HasAnyFlag(SpellAttributesEx.Channeled_1 | SpellAttributesEx.Channeled_2) ||	// don't use Enum.HasFlag!
				ChannelInterruptFlags > 0;

            IsPassive = (!IsChanneled && Attributes.HasFlag(SpellAttributes.Passive)) ||
				// tracking spells are also passive		     
						HasEffectWith(effect => effect.AuraType == AuraType.TrackCreatures) ||
						HasEffectWith(effect => effect.AuraType == AuraType.TrackResources) ||
						HasEffectWith(effect => effect.AuraType == AuraType.TrackStealthed);

			foreach (var effect in Effects)
			{
				effect.Init2();
				if (effect.IsHealEffect)
				{
					IsHealSpell = true;
				}
				if (effect.EffectType == SpellEffectType.NormalizedWeaponDamagePlus)
				{
					IsDualWieldAbility = true;
				}
			}

			InitAura();

			if (IsChanneled)
			{
				if (Durations.Min == 0)
				{
					Durations.Min = Durations.Max = 1000;
				}

				foreach (var effect in Effects)
				{
					if (effect.IsPeriodic)
					{
						ChannelAmplitude = effect.Amplitude;
						break;
					}
				}
			}

			IsOnNextStrike = Attributes.HasAnyFlag(SpellAttributes.OnNextMelee | SpellAttributes.OnNextMelee_2);	// don't use Enum.HasFlag!

			IsRangedAbility = !IsTriggeredSpell &&
				(Attributes.HasAnyFlag(SpellAttributes.Ranged) ||
					   AttributesExC.HasFlag(SpellAttributesExC.ShootRangedWeapon));

			IsStrikeSpell = HasEffectWith(effect => effect.IsStrikeEffect);

			IsWeaponAbility = IsRangedAbility || IsOnNextStrike || IsStrikeSpell;

			DamageIncreasedByAP = DamageIncreasedByAP || (PowerType == PowerType.Rage && SchoolMask == DamageSchoolMask.Physical);

			IsFinishingMove =
				AttributesEx.HasAnyFlag(SpellAttributesEx.FinishingMove) ||
				HasEffectWith(effect => effect.PointsPerComboPoint > 0 && effect.EffectType != SpellEffectType.Dummy);

			TotemEffect = GetFirstEffectWith(effect => effect.HasTarget(
				ImplicitTargetType.TotemAir, ImplicitTargetType.TotemEarth, ImplicitTargetType.TotemFire, ImplicitTargetType.TotemWater));

			// Required Item slot for weapon abilities
			if (RequiredItemClass == ItemClass.Armor && RequiredItemSubClassMask == ItemSubClassMask.Shield)
			{
				EquipmentSlot = EquipmentSlot.OffHand;
			}
			else
			{
				EquipmentSlot =
                    (IsRangedAbility || AttributesExC.HasFlag(SpellAttributesExC.RequiresWand)) ? EquipmentSlot.ExtraWeapon :
                    (AttributesExC.HasFlag(SpellAttributesExC.RequiresOffHandWeapon) ? EquipmentSlot.OffHand :
                    (AttributesExC.HasFlag(SpellAttributesExC.RequiresMainHandWeapon) ? EquipmentSlot.MainHand : EquipmentSlot.End));
			}

			HasIndividualCooldown = CooldownTime > 0 ||
				(IsWeaponAbility && !IsOnNextStrike && EquipmentSlot != EquipmentSlot.End);

			//IsAoe = HasEffectWith((effect) => {
			//    if (effect.ImplicitTargetA == ImplicitTargetType.)
			//        effect.ImplicitTargetA = ImplicitTargetType.None;
			//    if (effect.ImplicitTargetB == ImplicitTargetType.Unused_EnemiesInAreaChanneledWithExceptions)
			//        effect.ImplicitTargetB = ImplicitTargetType.None;
			//    return false;
			//});

			var profEffect = GetEffect(SpellEffectType.SkillStep);
			if (profEffect != null)
			{
				TeachesApprenticeAbility = profEffect.BasePoints == 0;
			}
//.........这里部分代码省略.........

		/// <summary>
		/// Tries to add a single new item with the given template to the given slot.
		/// Make sure the given targetSlot is valid before calling this method.
		/// </summary>
		public InventoryError TryAdd(ItemTemplate template, EquipmentSlot targetSlot)
		{
			var amount = 1;
			return TryAdd(template, ref amount, (int)targetSlot, true);
		}

		/// <summary>
		/// Checks if the given slot is occupied and -if so- puts the item from that slot into a free
		/// storage slot (within the backpack or any equipped bags).
		/// </summary>
		/// <returns>whether the given slot is now empty</returns>
		public bool EnsureEmpty(EquipmentSlot slot)
		{
			var item = this[slot];
			if (item == null)
			{
				return true;
			}

			var newSlotId = FindFreeSlot(item, item.Amount);
			if (newSlotId.Slot == INVALID_SLOT)
			{
				// no space left
				return false;
			}

			SwapUnchecked(this, (int)slot, newSlotId.Container, newSlotId.Slot);
			return true;
		}