/// <summary>
		/// Check if the slot is valid in the inventory
		/// </summary>
		/// <param name="slot">SlotPosition to check</param>
		/// <returns>the slot if it's valid or eInventorySlot.Invalid if not</returns>
		protected override eInventorySlot GetValidInventorySlot(eInventorySlot slot)
		{
			foreach (eInventorySlot visibleSlot in VISIBLE_SLOTS)
				if (visibleSlot == slot)
					return slot;
			return eInventorySlot.Invalid;
		}

        public void SwitchItem(GamePlayer player, eInventorySlot ToSlot, eInventorySlot FromSlot)
        {
            if (player.Inventory.GetItem(FromSlot) != null)
            {
                InventoryItem item = player.Inventory.GetItem(FromSlot);

                if (!GlobalConstants.IsWeapon(item.Object_Type))
                {
                    DisplayMessage(player.Client, "That is not a weapon!");
                    DisplaySyntax(player.Client);
                    return;
                }

                if (!player.Inventory.MoveItem(FromSlot, ToSlot, 1))
                {
                    DisplayMessage(player.Client, "There seems to have been a problem. Please try again.");
                    DisplaySyntax(player.Client);
                    return;
                }
            }
        }

		/// <summary>
		/// Overridden. Inventory template cannot be modified.
		/// </summary>
		/// <param name="fromSlot"></param>
		/// <param name="toSlot"></param>
		/// <param name="itemCount"></param>
		/// <returns></returns>
		public override bool MoveItem(eInventorySlot fromSlot, eInventorySlot toSlot, int itemCount)
		{
			return false;
		}

		/// <summary>
		/// Exchange two Items in form specified slot
		/// </summary>
		/// <param name="fromSlot">Source slot</param>
		/// <param name="toSlot">Destination slot</param>
		/// <param name="itemCount"></param>
		/// <returns>true if successfull false if not</returns>
		public virtual bool MoveItem(eInventorySlot fromSlot, eInventorySlot toSlot, int itemCount)
		{
			lock (m_items) // Mannen 10:56 PM 10/30/2006 - Fixing every lock(this)
			{
				fromSlot = GetValidInventorySlot(fromSlot);
				toSlot = GetValidInventorySlot(toSlot);
				if (fromSlot == eInventorySlot.Invalid || toSlot == eInventorySlot.Invalid)
					return false;

				InventoryItem fromItem;
				InventoryItem toItem;

				m_items.TryGetValue(fromSlot, out fromItem);
				m_items.TryGetValue(toSlot, out toItem);

				if (!CombineItems(fromItem, toItem) && !StackItems(fromSlot, toSlot, itemCount))
				{
					ExchangeItems(fromSlot, toSlot);
				}

				if (!m_changedSlots.Contains(fromSlot))
					m_changedSlots.Add(fromSlot);

				if (!m_changedSlots.Contains(toSlot))
					m_changedSlots.Add(toSlot);

				if (m_changesCounter <= 0)
					UpdateChangedSlots();

				return true;
			}
		}

		public virtual bool AddTradeItem(eInventorySlot slot, InventoryItem item)
		{
			return false;
		}

		/// <summary>
		/// Searches for the first occurrence of an item with given
		/// name between specified slots
		/// </summary>
		/// <param name="name">name</param>
		/// <param name="minSlot">fist slot for search</param>
		/// <param name="maxSlot">last slot for search</param>
		/// <returns>found item or null</returns>
		public InventoryItem GetFirstItemByName(string name, eInventorySlot minSlot, eInventorySlot maxSlot)
		{
			minSlot = GetValidInventorySlot(minSlot);
			maxSlot = GetValidInventorySlot(maxSlot);
			if (minSlot == eInventorySlot.Invalid || maxSlot == eInventorySlot.Invalid)
				return null;

			// If lower slot is greater than upper slot, flip the values.
			if (minSlot > maxSlot)
			{
				eInventorySlot tmp = minSlot;
				minSlot = maxSlot;
				maxSlot = tmp;
			}

			lock (m_items)
			{
				InventoryItem item;

				for (eInventorySlot i = minSlot; i <= maxSlot; i++)
				{
					if (m_items.TryGetValue(i, out item))
					{
						if (item.Name == name)
							return item;
					}
				}
			}

			return null;
		}

		/// <summary>
		/// Searches between two slots for the first or last full or empty slot
		/// </summary>
		/// <param name="first"></param>
		/// <param name="last"></param>
		/// <param name="searchFirst"></param>
		/// <param name="searchNull"></param>
		/// <returns></returns>
		protected virtual eInventorySlot FindSlot(eInventorySlot first, eInventorySlot last, bool searchFirst, bool searchNull)
		{
			lock (m_items) // Mannen 10:56 PM 10/30/2006 - Fixing every lock(this)
			{
				first = GetValidInventorySlot(first);
				last = GetValidInventorySlot(last);

				if (first == eInventorySlot.Invalid || last == eInventorySlot.Invalid)
					return eInventorySlot.Invalid;

				// If first/last slots are identical, check to see if the slot is full/empty and return based on
				// whether we instructed to find an empty or a full slot.
				if (first == last)
				{
					// If slot is empty, and we wanted an empty slot, or if slot is full, and we wanted
					// a full slot, return the given slot, otherwise return invalid.
					return !m_items.ContainsKey(first) == searchNull ? first : eInventorySlot.Invalid;
				}

				// If lower slot is greater than upper slot, flip the values.
				if (first > last)
				{
					eInventorySlot tmp = first;
					first = last;
					last = tmp;
				}

				for (int i = 0; i <= last - first; i++)
				{
					var testSlot = (int) (searchFirst ? (first + i) : (last - i));

					if (!m_items.ContainsKey((eInventorySlot) testSlot) == searchNull)
						return (eInventorySlot) testSlot;
				}

				return eInventorySlot.Invalid;
			}
		}

		/// <summary>
		/// Find the last full slot in the inventory
		/// </summary>
		/// <param name="first">SlotPosition to start the search</param>
		/// <param name="last">SlotPosition to stop the search</param>
		/// <returns>the empty inventory slot or eInventorySlot.Invalid</returns>
		public virtual eInventorySlot FindLastFullSlot(eInventorySlot first, eInventorySlot last)
		{
			return FindSlot(first, last, false, false);
		}

		/// <summary>
		/// Checks if specified count of slots is free
		/// </summary>
		/// <param name="count"></param>
		/// <param name="minSlot"></param>
		/// <param name="maxSlot"></param>
		/// <returns></returns>
		public bool IsSlotsFree(int count, eInventorySlot minSlot, eInventorySlot maxSlot)
		{
			if (count < 1)
				return true;

			// If lower slot is greater than upper slot, flip the values.
			if (minSlot > maxSlot)
			{
				eInventorySlot tmp = minSlot;
				minSlot = maxSlot;
				maxSlot = tmp;
			}

			lock (m_items) // Mannen 10:56 PM 10/30/2006 - Fixing every lock(this)
			{
				for (eInventorySlot i = minSlot; i <= maxSlot; i++)
				{
					if (m_items.ContainsKey(i))
						continue;

					count--;

					if (count <= 0)
						return true;
				}

				return false;
			}
		}

        /// <summary>
        /// The Player is buying an Item from the merchant
        /// </summary>
        /// <param name="player"></param>
        /// <param name="playerInventory"></param>
        /// <param name="fromClientSlot"></param>
        /// <param name="toClientSlot"></param>
		public virtual void OnPlayerBuy(GamePlayer player, eInventorySlot fromClientSlot, eInventorySlot toClientSlot, bool usingMarketExplorer = false)
        {
			IDictionary<int, InventoryItem> clientInventory = GetClientInventory(player);

			InventoryItem fromItem = null;

			if (clientInventory.ContainsKey((int)fromClientSlot))
			{
				fromItem = clientInventory[(int)fromClientSlot];
			}

			if (fromItem == null)
			{
				ChatUtil.SendErrorMessage(player, "I can't find the item you want to purchase!");
				log.ErrorFormat("CM: {0}:{1} can't find item to buy in slot {2} on consignment merchant on lot {3}.", player.Name, player.Client.Account, (int)fromClientSlot, HouseNumber);
				return;
			}

			string buyText = "Do you want to buy this Item?";

			// If the player has a marketExplorer activated they will be charged a commission
			if (player.TargetObject is MarketExplorer)
			{
				player.TempProperties.setProperty(CONSIGNMENT_BUY_ITEM, fromClientSlot);
				if (ServerProperties.Properties.MARKET_FEE_PERCENT > 0)
				{
					player.Out.SendCustomDialog("Buying directly from the Market Explorer costs an additional " +  ServerProperties.Properties.MARKET_FEE_PERCENT + "% fee. Do you want to buy this Item?", new CustomDialogResponse(BuyMarketResponse));
				}
				else
				{
					player.Out.SendCustomDialog(buyText, new CustomDialogResponse(BuyResponse));
				}
			}
			else if (player.TargetObject == this)
			{
				player.TempProperties.setProperty(CONSIGNMENT_BUY_ITEM, fromClientSlot);
				player.Out.SendCustomDialog(buyText, new CustomDialogResponse(BuyResponse));
			}
			else
			{
				ChatUtil.SendErrorMessage(player, "I'm sorry, you need to be talking to a market explorer or consignment merchant in order to make a purchase.");
				log.ErrorFormat("CM: {0}:{1} did not have a CM or ME targeted when attempting to purchase {2} on consignment merchant on lot {3}.", player.Name, player.Client.Account, fromItem.Name, HouseNumber);
			}
        }

		/// <summary>
		/// Adds item to template reusing inventory item instances from other templates.
		/// </summary>
		/// <param name="slot">The equipment slot</param>
		/// <param name="model">The equipment model</param>
		/// <returns>true if added</returns>
		public bool AddNPCEquipment(eInventorySlot slot, int model)
		{
			return AddNPCEquipment(slot, model, 0, 0, 0);
		}

		/// <summary>
		/// Overridden. Inventory template cannot be modified.
		/// </summary>
		/// <param name="templateID">The ItemTemplate ID</param>
		/// <param name="count">The count of items to add</param>
		/// <param name="minSlot">The first slot</param>
		/// <param name="maxSlot">The last slot</param>
		/// <returns>false</returns>
		public override bool RemoveTemplate(string templateID, int count, eInventorySlot minSlot, eInventorySlot maxSlot)
		{
			return false;
		}

		/// <summary>
		/// Overridden. Inventory template cannot be modified.
		/// </summary>
		/// <param name="template">The ItemTemplate</param>
		/// <param name="count">The count of items to add</param>
		/// <param name="minSlot">The first slot</param>
		/// <param name="maxSlot">The last slot</param>
		/// <returns>false</returns>
		public override bool AddTemplate(InventoryItem template, int count, eInventorySlot minSlot, eInventorySlot maxSlot)
		{
			return false;
		}

		/// <summary>
		/// Overridden. Inventory template cannot be modified.
		/// </summary>
		/// <param name="fromSlot">First SlotPosition</param>
		/// <param name="toSlot">Second SlotPosition</param>
		/// <returns>false</returns>
		protected override bool ExchangeItems(eInventorySlot fromSlot, eInventorySlot toSlot)
		{
			return false;
		}

		/// <summary>
		/// Overridden. Inventory template cannot be modified.
		/// </summary>
		/// <param name="fromSlot">First SlotPosition</param>
		/// <param name="toSlot">Second SlotPosition</param>
		/// <param name="itemCount">How many items to move</param>
		/// <returns>false</returns>
		protected override bool StackItems(eInventorySlot fromSlot, eInventorySlot toSlot, int itemCount)
		{
			return false;
		}

		/// <summary>
		/// Counts used/free slots between min and max
		/// </summary>
		/// <param name="countUsed"></param>
		/// <param name="minSlot"></param>
		/// <param name="maxSlot"></param>
		/// <returns></returns>
		public int CountSlots(bool countUsed, eInventorySlot minSlot, eInventorySlot maxSlot)
		{
			// If lower slot is greater than upper slot, flip the values.
			if (minSlot > maxSlot)
			{
				eInventorySlot tmp = minSlot;
				minSlot = maxSlot;
				maxSlot = tmp;
			}

			int result = 0;

			lock (m_items) // Mannen 10:56 PM 10/30/2006 - Fixing every lock(this)
			{
				for (eInventorySlot i = minSlot; i <= maxSlot; i++)
				{
					if (m_items.ContainsKey(i))
					{
						if (countUsed)
							result++;
					}
					else
					{
						if (!countUsed)
							result++;
					}
				}

				return result;
			}
		}

		/// <summary>
		/// Count items of some type
		/// </summary>
		/// <param name="itemtemplateID">template to count</param>
		/// <param name="minSlot">first slot</param>
		/// <param name="maxSlot">last slot</param>
		/// <returns>number of matched items found</returns>
		public int CountItemTemplate(string itemtemplateID, eInventorySlot minSlot, eInventorySlot maxSlot)
		{
			lock (m_items) // Mannen 10:56 PM 10/30/2006 - Fixing every lock(this)
			{
				int count = 0;

				// If lower slot is greater than upper slot, flip the values.
				if (minSlot > maxSlot)
				{
					eInventorySlot tmp = minSlot;
					minSlot = maxSlot;
					maxSlot = tmp;
				}

				InventoryItem item;

				for (eInventorySlot i = minSlot; i <= maxSlot; i++)
				{
					if (m_items.TryGetValue(i, out item) && item.Id_nb == itemtemplateID)
					{
						count += item.Count;
					}
				}

				return count++;
			}
		}

		/// <summary>
		/// Changes the commander's weapon to the specified type
		/// </summary>
		/// <param name="slot"></param>
		/// <param name="aSlot"></param>
		/// <param name="weaponType"></param>
		protected void CommanderSwitchWeapon(eInventorySlot slot, eActiveWeaponSlot aSlot, string weaponType)
		{
			if (Inventory == null)
				return;

			string itemId = string.Format("BD_Commander_{0}_{1}", slot.ToString(), weaponType);
			//all weapons removed before
			InventoryItem item = Inventory.GetItem(eInventorySlot.RightHandWeapon);
			if (item != null) Inventory.RemoveItem(item);
			item = Inventory.GetItem(eInventorySlot.TwoHandWeapon);
			if (item != null) Inventory.RemoveItem(item);

			ItemTemplate temp = GameServer.Database.FindObjectByKey<ItemTemplate>(itemId);

			if (temp == null)
			{
				if (log.IsErrorEnabled)
					log.Error(string.Format("Unable to find Bonedancer item: {0}", itemId));
				return;
			}

			Inventory.AddItem(slot, GameInventoryItem.Create<ItemTemplate>(temp));
			SwitchWeapon(aSlot);
			AddStatsToWeapon();
			BroadcastLivingEquipmentUpdate();
		}

		/// <summary>
		/// Find the last empty slot in the inventory
		/// </summary>
		/// <param name="first">SlotPosition to start the search</param>
		/// <param name="last">SlotPosition to stop the search</param>
		/// <returns>the empty inventory slot or eInventorySlot.Invalid</returns>
		public virtual eInventorySlot FindLastEmptySlot(eInventorySlot first, eInventorySlot last)
		{
			return FindSlot(first, last, false, true);
		}

		/// <summary>
		/// Move an item from the inventory object to a player's backpack (uses client slots)
		/// </summary>
		public static IDictionary<int, InventoryItem> MoveItemFromObject(this IGameInventoryObject thisObject, GamePlayer player, eInventorySlot fromClientSlot, eInventorySlot toClientSlot)
		{
			// We will only allow moving to the backpack.

			if (toClientSlot < eInventorySlot.FirstBackpack || toClientSlot > eInventorySlot.LastBackpack)
				return null;

			lock (thisObject.LockObject())
			{
				Dictionary<int, InventoryItem> inventory = thisObject.GetClientInventory(player);

				if (inventory.ContainsKey((int)fromClientSlot) == false)
				{
					ChatUtil.SendErrorMessage(player, "Item not found in slot " + (int)fromClientSlot);
					return null;
				}

				InventoryItem fromItem = inventory[(int)fromClientSlot];
				InventoryItem toItem = player.Inventory.GetItem(toClientSlot);

				// if there is an item in the players target inventory slot then move it to the object
				if (toItem != null)
				{
					player.Inventory.RemoveTradeItem(toItem);
					toItem.SlotPosition = fromItem.SlotPosition;
					toItem.OwnerID = thisObject.GetOwner(player);
					thisObject.OnAddItem(player, toItem);
					GameServer.Database.SaveObject(toItem);
				}

				thisObject.OnRemoveItem(player, fromItem);

				// Create the GameInventoryItem from this InventoryItem.  This simply wraps the InventoryItem, 
				// which is still updated when this item is moved around
				InventoryItem objectItem = GameInventoryItem.Create<InventoryItem>(fromItem);

				player.Inventory.AddTradeItem(toClientSlot, objectItem);

				var updateItems = new Dictionary<int, InventoryItem>(1);
				updateItems.Add((int)fromClientSlot, toItem);

				return updateItems;
			}
		}