UltimateFishing2020/Assets/Scripts/Assembly-CSharp/EquipPopup.cs

using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.UI;

public class EquipPopup : MonoBehaviour
{
	public Transform ItemsContainer;

	public Transform ItemsInfoContainer;

	public Transform ItemsInfoContainerBait;

	public GameObject equipButton;

	public GameObject equipButtonBait;

	public GameObject repairButton;

	public GameObject repairButtonBait;

	public GameObject unEquipButton;

	public GameObject unEquipButtonBait;

	public Text reapairCost;

	public GameObject statsAndButtonsContainer;

	public GameObject statsAndButtonsContainerBait;

	public Button view3DButton;

	public Button view3DButtonBait;

	public GameManager.ItemType itemType;

	public int uniqueId = -1;

	public int currentSlotindex;

	public Image logoBrandImage;

	public Image bigImage;

	public Text nameItemText;

	public Text statsItemText;

	public Text descriptionItemText;

	public Image logoBrandImageBait;

	public Image bigImageBait;

	public Text nameItemTextBait;

	public Text TypeTextBait;

	public Text LevelTextBait;

	public Text WeightTextBait;

	public Text descriptionItemTextBait;

	public Text takesOnTextBait;

	public Text NoneFishTextBait;

	public Transform TakingFishBaitContainer;

	public GameObject FishListItemPrefab;

	public Scrollbar FishListItemScrollBar;

	public Transform[] sortingTabsContents;

	private EquipmentManager equipmentManager;

	private SlotItem currentItemSelected;

	[SerializeField]
	private SlotItem currentItemEquiped;

	private string currentSortString = "ALL";

	public InstallSignalizer installSignalizerOptionsContent;

	public static event Action OnItemEquipGlobal;

	public static event Action OnItemRepairGlobal;

	private void Start()
	{
	}

	public void RefreshSort()
	{
		ShowItemsSort(currentSortString);
	}

	public void ShowItemsFromSort(string sortName)
	{
		currentSortString = sortName;
		ShowItemsSort(sortName, resetInfoContainer: true);
	}

	public void ShowItemsSort(string sortName, bool resetInfoContainer = false)
	{
		GameManager.TruncateContainer(ItemsContainer);
		if (resetInfoContainer)
		{
			ItemsInfoContainer.gameObject.SetActive(value: false);
			ItemsInfoContainerBait.gameObject.SetActive(value: false);
			currentItemSelected = null;
		}
		statsAndButtonsContainer.SetActive(value: true);
		statsAndButtonsContainerBait.SetActive(value: true);
		int num = 0;
		GameManager.ItemType itemType = this.itemType;
		if (itemType == GameManager.ItemType.Leader || (uint)(itemType - 9) <= 1u)
		{
			view3DButton.gameObject.SetActive(value: false);
			view3DButtonBait.gameObject.SetActive(value: false);
		}
		else
		{
			view3DButton.gameObject.SetActive(value: false);
			view3DButtonBait.gameObject.SetActive(value: false);
		}
		Debug.Log("ShowItemsFromSort " + sortName);
		switch (this.itemType)
		{
		case GameManager.ItemType.Rod:
			switch (sortName)
			{
			case "ALL":
			{
				for (int num6 = 0; num6 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods.Count; num6++)
				{
					CreateItemSlotRod(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num6]);
					num++;
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].rod.isNull)
				{
					CreateItemSlotRod(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].rod, isEquiped: true);
					num++;
				}
				break;
			}
			case "UNIVERSAL":
			{
				for (int num7 = 0; num7 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods.Count; num7++)
				{
					int itemIdByUniqueId8 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num7].uniqueId);
					if (GameManager.Instance.gameRods[itemIdByUniqueId8].type == GameManager.GameRods.Type.Universal)
					{
						CreateItemSlotRod(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num7]);
						num++;
					}
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].rod.isNull)
				{
					CreateItemSlotRod(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].rod, isEquiped: true);
					num++;
				}
				break;
			}
			case "FLOAT":
			{
				for (int num10 = 0; num10 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods.Count; num10++)
				{
					int itemIdByUniqueId11 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num10].uniqueId);
					if (GameManager.Instance.gameRods[itemIdByUniqueId11].type == GameManager.GameRods.Type.Float)
					{
						CreateItemSlotRod(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num10]);
						num++;
					}
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].rod.isNull)
				{
					CreateItemSlotRod(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].rod, isEquiped: true);
					num++;
				}
				break;
			}
			case "SPINNING":
			{
				for (int num8 = 0; num8 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods.Count; num8++)
				{
					int itemIdByUniqueId9 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num8].uniqueId);
					if (GameManager.Instance.gameRods[itemIdByUniqueId9].type == GameManager.GameRods.Type.Spinning)
					{
						CreateItemSlotRod(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num8]);
						num++;
					}
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].rod.isNull)
				{
					CreateItemSlotRod(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].rod, isEquiped: true);
					num++;
				}
				break;
			}
			case "CASTING":
			{
				for (int num9 = 0; num9 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods.Count; num9++)
				{
					int itemIdByUniqueId10 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num9].uniqueId);
					if (GameManager.Instance.gameRods[itemIdByUniqueId10].type == GameManager.GameRods.Type.Casting)
					{
						CreateItemSlotRod(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num9]);
						num++;
					}
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].rod.isNull)
				{
					CreateItemSlotRod(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].rod, isEquiped: true);
					num++;
				}
				break;
			}
			case "FEEDER":
			{
				for (int num5 = 0; num5 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods.Count; num5++)
				{
					int itemIdByUniqueId7 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num5].uniqueId);
					if (GameManager.Instance.gameRods[itemIdByUniqueId7].type == GameManager.GameRods.Type.Feeder)
					{
						CreateItemSlotRod(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num5]);
						num++;
					}
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].rod.isNull)
				{
					CreateItemSlotRod(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].rod, isEquiped: true);
					num++;
				}
				break;
			}
			}
			break;
		case GameManager.ItemType.Reel:
			switch (sortName)
			{
			case "ALL":
			{
				for (int num3 = 0; num3 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels.Count; num3++)
				{
					CreateItemSlotReel(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num3]);
					num++;
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].reel.isNull)
				{
					CreateItemSlotReel(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].reel, isEquiped: true);
					num++;
				}
				break;
			}
			case "UNIVERSAL":
			{
				for (int num4 = 0; num4 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels.Count; num4++)
				{
					int itemIdByUniqueId6 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num4].uniqueId);
					if (GameManager.Instance.gameReels[itemIdByUniqueId6].type == GameManager.GameReels.Type.Universal)
					{
						CreateItemSlotReel(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num4]);
						num++;
					}
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].reel.isNull)
				{
					CreateItemSlotReel(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].reel, isEquiped: true);
					num++;
				}
				break;
			}
			case "SPINNING":
			{
				for (int num2 = 0; num2 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels.Count; num2++)
				{
					int itemIdByUniqueId5 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num2].uniqueId);
					if (GameManager.Instance.gameReels[itemIdByUniqueId5].type == GameManager.GameReels.Type.Spinning)
					{
						CreateItemSlotReel(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num2]);
						num++;
					}
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].reel.isNull)
				{
					CreateItemSlotReel(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].reel, isEquiped: true);
					num++;
				}
				break;
			}
			case "CASTING":
			{
				for (int n = 0; n < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels.Count; n++)
				{
					int itemIdByUniqueId4 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[n].uniqueId);
					if (GameManager.Instance.gameReels[itemIdByUniqueId4].type == GameManager.GameReels.Type.Casting)
					{
						CreateItemSlotReel(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[n]);
						num++;
					}
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].reel.isNull)
				{
					CreateItemSlotReel(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].reel, isEquiped: true);
					num++;
				}
				break;
			}
			}
			break;
		case GameManager.ItemType.Line:
			switch (sortName)
			{
			case "ALL":
			{
				for (int num32 = 0; num32 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines.Count; num32++)
				{
					CreateItemSlotLine(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[num32]);
					num++;
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].line.isNull)
				{
					CreateItemSlotLine(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].line, isEquiped: true);
					num++;
				}
				break;
			}
			case "MONO":
			{
				for (int num33 = 0; num33 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines.Count; num33++)
				{
					int itemIdByUniqueId29 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[num33].uniqueId);
					if (GameManager.Instance.gameLines[itemIdByUniqueId29].type == GameManager.GameLines.Type.Mono)
					{
						CreateItemSlotLine(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[num33]);
						num++;
					}
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].line.isNull)
				{
					CreateItemSlotLine(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].line, isEquiped: true);
					num++;
				}
				break;
			}
			case "FLURO":
			{
				for (int num31 = 0; num31 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines.Count; num31++)
				{
					int itemIdByUniqueId28 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[num31].uniqueId);
					if (GameManager.Instance.gameLines[itemIdByUniqueId28].type == GameManager.GameLines.Type.Fluro)
					{
						CreateItemSlotLine(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[num31]);
						num++;
					}
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].line.isNull)
				{
					CreateItemSlotLine(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].line, isEquiped: true);
					num++;
				}
				break;
			}
			case "BRAID":
			{
				for (int num30 = 0; num30 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines.Count; num30++)
				{
					int itemIdByUniqueId27 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[num30].uniqueId);
					if (GameManager.Instance.gameLines[itemIdByUniqueId27].type == GameManager.GameLines.Type.Braid)
					{
						CreateItemSlotLine(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[num30]);
						num++;
					}
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].line.isNull)
				{
					CreateItemSlotLine(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].line, isEquiped: true);
					num++;
				}
				break;
			}
			}
			break;
		case GameManager.ItemType.Float:
			switch (sortName)
			{
			case "ALL":
			{
				for (int num17 = 0; num17 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats.Count; num17++)
				{
					CreateItemSlotFloat(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[num17]);
					num++;
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].ffloat.isNull)
				{
					CreateItemSlotFloat(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].ffloat, isEquiped: true);
					num++;
				}
				break;
			}
			case "SLIDER":
			{
				for (int num18 = 0; num18 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats.Count; num18++)
				{
					int itemIdByUniqueId17 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[num18].uniqueId);
					if (GameManager.Instance.gameFloats[itemIdByUniqueId17].type == GameManager.GameFloats.Type.Slider)
					{
						CreateItemSlotFloat(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[num18]);
						num++;
					}
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].ffloat.isNull)
				{
					CreateItemSlotFloat(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].ffloat, isEquiped: true);
					num++;
				}
				break;
			}
			case "WAGGLER":
			{
				for (int num16 = 0; num16 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats.Count; num16++)
				{
					int itemIdByUniqueId16 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[num16].uniqueId);
					if (GameManager.Instance.gameFloats[itemIdByUniqueId16].type == GameManager.GameFloats.Type.Waggler)
					{
						CreateItemSlotFloat(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[num16]);
						num++;
					}
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].ffloat.isNull)
				{
					CreateItemSlotFloat(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].ffloat, isEquiped: true);
					num++;
				}
				break;
			}
			}
			break;
		case GameManager.ItemType.Leader:
			switch (sortName)
			{
			case "ALL":
			{
				for (int num13 = 0; num13 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders.Count; num13++)
				{
					CreateItemSlotLeader(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[num13]);
					num++;
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].leader.isNull)
				{
					CreateItemSlotLeader(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].leader, isEquiped: true);
					num++;
				}
				break;
			}
			case "MONO":
			{
				for (int num14 = 0; num14 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders.Count; num14++)
				{
					int itemIdByUniqueId14 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[num14].uniqueId);
					if (GameManager.Instance.gameLeaders[itemIdByUniqueId14].type == GameManager.GameLeaders.Type.Mono)
					{
						CreateItemSlotLeader(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[num14]);
						num++;
					}
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].leader.isNull)
				{
					CreateItemSlotLeader(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].leader, isEquiped: true);
					num++;
				}
				break;
			}
			case "STEEL":
			{
				for (int num12 = 0; num12 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders.Count; num12++)
				{
					int itemIdByUniqueId13 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[num12].uniqueId);
					if (GameManager.Instance.gameLeaders[itemIdByUniqueId13].type == GameManager.GameLeaders.Type.Steel)
					{
						CreateItemSlotLeader(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[num12]);
						num++;
					}
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].leader.isNull)
				{
					CreateItemSlotLeader(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].leader, isEquiped: true);
					num++;
				}
				break;
			}
			case "TITANIUM":
			{
				for (int num15 = 0; num15 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders.Count; num15++)
				{
					int itemIdByUniqueId15 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[num15].uniqueId);
					if (GameManager.Instance.gameLeaders[itemIdByUniqueId15].type == GameManager.GameLeaders.Type.Titanium)
					{
						CreateItemSlotLeader(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[num15]);
						num++;
					}
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].leader.isNull)
				{
					CreateItemSlotLeader(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].leader, isEquiped: true);
					num++;
				}
				break;
			}
			case "WIRE":
			{
				for (int num11 = 0; num11 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders.Count; num11++)
				{
					int itemIdByUniqueId12 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[num11].uniqueId);
					if (GameManager.Instance.gameLeaders[itemIdByUniqueId12].type == GameManager.GameLeaders.Type.Wire)
					{
						CreateItemSlotLeader(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[num11]);
						num++;
					}
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].leader.isNull)
				{
					CreateItemSlotLeader(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].leader, isEquiped: true);
					num++;
				}
				break;
			}
			}
			break;
		case GameManager.ItemType.Feeder:
			if (!(sortName == "ALL"))
			{
				if (!(sortName == "FEEDER"))
				{
					break;
				}
				for (int num28 = 0; num28 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders.Count; num28++)
				{
					int itemIdByUniqueId26 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[num28].uniqueId);
					if (GameManager.Instance.gameFeeders[itemIdByUniqueId26].type == GameManager.GameFeeders.Type.Feeder)
					{
						CreateItemSlotFeeder(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[num28]);
						num++;
					}
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].feeder.isNull)
				{
					CreateItemSlotFeeder(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].feeder, isEquiped: true);
					num++;
				}
			}
			else
			{
				for (int num29 = 0; num29 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders.Count; num29++)
				{
					CreateItemSlotFeeder(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[num29]);
					num++;
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].feeder.isNull)
				{
					CreateItemSlotFeeder(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].feeder, isEquiped: true);
					num++;
				}
			}
			break;
		case GameManager.ItemType.Hook:
			switch (sortName)
			{
			case "ALL":
			{
				for (int num23 = 0; num23 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks.Count; num23++)
				{
					CreateItemSlotHook(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num23]);
					num++;
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].hook.isNull)
				{
					CreateItemSlotHook(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].hook, isEquiped: true);
					num++;
				}
				break;
			}
			case "ABERDEEN":
			{
				for (int num24 = 0; num24 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks.Count; num24++)
				{
					int itemIdByUniqueId22 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num24].uniqueId);
					if (GameManager.Instance.gameHooks[itemIdByUniqueId22].type == GameManager.GameHooks.Type.Aberdeen)
					{
						CreateItemSlotHook(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num24]);
						num++;
					}
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].hook.isNull)
				{
					CreateItemSlotHook(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].hook, isEquiped: true);
					num++;
				}
				break;
			}
			case "BAIT":
			{
				for (int num27 = 0; num27 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks.Count; num27++)
				{
					int itemIdByUniqueId25 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num27].uniqueId);
					if (GameManager.Instance.gameHooks[itemIdByUniqueId25].type == GameManager.GameHooks.Type.Bait)
					{
						CreateItemSlotHook(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num27]);
						num++;
					}
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].hook.isNull)
				{
					CreateItemSlotHook(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].hook, isEquiped: true);
					num++;
				}
				break;
			}
			case "CIRCLE":
			{
				for (int num25 = 0; num25 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks.Count; num25++)
				{
					int itemIdByUniqueId23 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num25].uniqueId);
					if (GameManager.Instance.gameHooks[itemIdByUniqueId23].type == GameManager.GameHooks.Type.Circle)
					{
						CreateItemSlotHook(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num25]);
						num++;
					}
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].hook.isNull)
				{
					CreateItemSlotHook(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].hook, isEquiped: true);
					num++;
				}
				break;
			}
			case "OCTOPUS":
			{
				for (int num26 = 0; num26 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks.Count; num26++)
				{
					int itemIdByUniqueId24 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num26].uniqueId);
					if (GameManager.Instance.gameHooks[itemIdByUniqueId24].type == GameManager.GameHooks.Type.Octopus)
					{
						CreateItemSlotHook(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num26]);
						num++;
					}
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].hook.isNull)
				{
					CreateItemSlotHook(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].hook, isEquiped: true);
					num++;
				}
				break;
			}
			case "TREBLE":
			{
				for (int num22 = 0; num22 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks.Count; num22++)
				{
					int itemIdByUniqueId21 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num22].uniqueId);
					if (GameManager.Instance.gameHooks[itemIdByUniqueId21].type == GameManager.GameHooks.Type.Treble)
					{
						CreateItemSlotHook(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num22]);
						num++;
					}
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].hook.isNull)
				{
					CreateItemSlotHook(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].hook, isEquiped: true);
					num++;
				}
				break;
			}
			}
			break;
		case GameManager.ItemType.Bait:
			switch (sortName)
			{
			case "ALL":
			{
				for (int num21 = 0; num21 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits.Count; num21++)
				{
					int itemIdByUniqueId20 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[num21].uniqueId);
					int indexByItemId5 = GameManager.Instance.GetIndexByItemId(this.itemType, itemIdByUniqueId20);
					if (indexByItemId5 == -1)
					{
						Debug.LogWarning($"[ITEM DOESNT EXIST] Item with ID {itemIdByUniqueId20} doesnt exists in GameBaits");
						continue;
					}
					if (GameManager.Instance.gameBaits[indexByItemId5].type == GameManager.GameBaits.Type.Natural)
					{
						CreateItemSlotBait(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[num21]);
						num++;
					}
					if (GameManager.Instance.gameBaits[indexByItemId5].type == GameManager.GameBaits.Type.Spinning)
					{
						CreateItemSlotBait(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[num21], isEquiped: false, GameManager.GameBaits.Type.Spinning);
						num++;
					}
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].bait.isNull)
				{
					int indexByItemId6 = GameManager.Instance.GetIndexByItemId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].bait.ID);
					if (GameManager.Instance.gameBaits[indexByItemId6].type == GameManager.GameBaits.Type.Natural)
					{
						CreateItemSlotBait(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].bait, isEquiped: true);
						num++;
					}
					if (GameManager.Instance.gameBaits[indexByItemId6].type == GameManager.GameBaits.Type.Spinning)
					{
						CreateItemSlotBait(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].bait, isEquiped: true, GameManager.GameBaits.Type.Spinning);
						num++;
					}
				}
				break;
			}
			case "BAIT":
			{
				for (int num20 = 0; num20 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits.Count; num20++)
				{
					int itemIdByUniqueId19 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[num20].uniqueId);
					int indexByItemId3 = GameManager.Instance.GetIndexByItemId(this.itemType, itemIdByUniqueId19);
					if (indexByItemId3 == -1)
					{
						Debug.LogWarning($"[ITEM DOESNT EXIST] Item with ID {itemIdByUniqueId19} doesnt exists in GameBaits");
					}
					else if (GameManager.Instance.gameBaits[indexByItemId3].type == GameManager.GameBaits.Type.Natural)
					{
						CreateItemSlotBait(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[num20]);
						num++;
					}
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].bait.isNull)
				{
					int indexByItemId4 = GameManager.Instance.GetIndexByItemId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].bait.ID);
					if (GameManager.Instance.gameBaits[indexByItemId4].type == GameManager.GameBaits.Type.Natural)
					{
						CreateItemSlotBait(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].bait, isEquiped: true);
						num++;
					}
				}
				break;
			}
			case "LURE":
			{
				for (int num19 = 0; num19 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits.Count; num19++)
				{
					int itemIdByUniqueId18 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[num19].uniqueId);
					int indexByItemId = GameManager.Instance.GetIndexByItemId(this.itemType, itemIdByUniqueId18);
					if (indexByItemId == -1)
					{
						Debug.LogWarning($"[ITEM DOESNT EXIST] Item with ID {itemIdByUniqueId18} doesnt exists in GameBaits");
					}
					else if (GameManager.Instance.gameBaits[indexByItemId].type == GameManager.GameBaits.Type.Spinning)
					{
						CreateItemSlotBait(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[num19], isEquiped: false, GameManager.GameBaits.Type.Spinning);
						num++;
					}
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].bait.isNull)
				{
					int indexByItemId2 = GameManager.Instance.GetIndexByItemId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].bait.ID);
					if (GameManager.Instance.gameBaits[indexByItemId2].type == GameManager.GameBaits.Type.Spinning)
					{
						CreateItemSlotBait(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].bait, isEquiped: true, GameManager.GameBaits.Type.Spinning);
						num++;
					}
				}
				break;
			}
			}
			break;
		case GameManager.ItemType.Weight:
			if (sortName == "ALL")
			{
				for (int m = 0; m < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights.Count; m++)
				{
					CreateItemSlotWeight(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[m]);
					num++;
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].weight.isNull)
				{
					CreateItemSlotWeight(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotindex].weight, isEquiped: true);
					num++;
				}
			}
			break;
		case GameManager.ItemType.Accesories:
			switch (sortName)
			{
			case "ALL":
			{
				for (int l = 0; l < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories.Count; l++)
				{
					CreateItemSlot(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[l].ID, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[l].uniqueId);
					num++;
				}
				break;
			}
			case "ROD_SUPPORT":
			{
				for (int j = 0; j < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories.Count; j++)
				{
					int itemIdByUniqueId2 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[j].uniqueId);
					if (GameManager.Instance.gameAccesories[itemIdByUniqueId2].type == GameManager.GameAccesories.Type.RodSupport)
					{
						CreateItemSlot(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[j].ID, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[j].uniqueId);
						num++;
					}
				}
				break;
			}
			case "BITE_SIGNALIZERS":
			{
				for (int k = 0; k < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories.Count; k++)
				{
					int itemIdByUniqueId3 = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[k].uniqueId);
					if (GameManager.Instance.gameAccesories[itemIdByUniqueId3].type == GameManager.GameAccesories.Type.Signalizers)
					{
						CreateItemSlot(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[k].ID, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[k].uniqueId);
						num++;
					}
				}
				break;
			}
			case "SLINGSHOTS":
			{
				for (int i = 0; i < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories.Count; i++)
				{
					int itemIdByUniqueId = GameManager.Instance._playerData.GetItemIdByUniqueId(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[i].uniqueId);
					if (GameManager.Instance.gameAccesories[itemIdByUniqueId].type == GameManager.GameAccesories.Type.Slingshots)
					{
						CreateItemSlot(this.itemType, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[i].ID, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[i].uniqueId);
						num++;
					}
				}
				break;
			}
			}
			break;
		}
		if (num == 0)
		{
			GameManager.Instance.ShowMessagePopup(LanguageManager.Instance.GetText("EQUIPMENT_ITEMS_EMPTY"), equipmentManager.GetComponent<Canvas>().transform);
		}
		Debug.Log("ItemsAvailableCount " + num);
	}

	private void CreateItemSlotRod(GameManager.PlayerData.CRods rod, bool isEquiped = false)
	{
		SlotItem component = UnityEngine.Object.Instantiate(equipmentManager.slotItemPrefab, ItemsContainer).GetComponent<SlotItem>();
		component.transform.SetAsFirstSibling();
		component.itemType = GameManager.ItemType.Rod;
		component.rod = rod;
		component.currentSlotIndex = currentSlotindex;
		component.Setup(itemType, rod.ID, rod.uniqueId, isEmpty: false, isEquiped);
		if (isEquiped)
		{
			component.itemStatusText.gameObject.SetActive(value: true);
			component.itemStatusText.text = LanguageManager.Instance.GetText("EQUIPPED").ToUpper();
			currentItemEquiped = component;
			component.deleteItemButton.gameObject.SetActive(value: false);
		}
		else
		{
			component.itemStatusText.gameObject.SetActive(value: false);
			component.deleteItemButton.gameObject.SetActive(value: true);
		}
		if ((bool)currentItemSelected && currentItemSelected.itemType == component.itemType && currentItemSelected.itemUniqueId == component.itemUniqueId)
		{
			component.SetColorItem(currentItemSelected.selectedColor);
			currentItemSelected = component;
		}
	}

	private void CreateItemSlotReel(GameManager.PlayerData.CReels reel, bool isEquiped = false)
	{
		SlotItem component = UnityEngine.Object.Instantiate(equipmentManager.slotItemPrefab, ItemsContainer).GetComponent<SlotItem>();
		component.transform.SetAsFirstSibling();
		component.itemType = GameManager.ItemType.Reel;
		component.reel = reel;
		component.currentSlotIndex = currentSlotindex;
		component.Setup(itemType, reel.ID, reel.uniqueId, isEmpty: false, isEquiped);
		if (isEquiped)
		{
			component.itemStatusText.gameObject.SetActive(value: true);
			component.itemStatusText.text = LanguageManager.Instance.GetText("EQUIPPED").ToUpper();
			currentItemEquiped = component;
			component.deleteItemButton.gameObject.SetActive(value: false);
		}
		else
		{
			component.itemStatusText.gameObject.SetActive(value: false);
			component.deleteItemButton.gameObject.SetActive(value: true);
		}
		if ((bool)currentItemSelected && currentItemSelected.itemType == component.itemType && currentItemSelected.itemUniqueId == component.itemUniqueId)
		{
			component.SetColorItem(currentItemSelected.selectedColor);
			currentItemSelected = component;
		}
	}

	private void CreateItemSlotLine(GameManager.PlayerData.CLines line, bool isEquiped = false)
	{
		SlotItem component = UnityEngine.Object.Instantiate(equipmentManager.slotItemPrefab, ItemsContainer).GetComponent<SlotItem>();
		component.transform.SetAsFirstSibling();
		component.itemType = GameManager.ItemType.Line;
		component.line = line;
		component.currentSlotIndex = currentSlotindex;
		component.Setup(itemType, line.ID, line.uniqueId, isEmpty: false, isEquiped);
		if (isEquiped)
		{
			component.itemStatusText.gameObject.SetActive(value: true);
			component.itemStatusText.text = LanguageManager.Instance.GetText("EQUIPPED").ToUpper();
			currentItemEquiped = component;
			component.deleteItemButton.gameObject.SetActive(value: false);
		}
		else
		{
			component.itemStatusText.gameObject.SetActive(value: false);
			component.deleteItemButton.gameObject.SetActive(value: true);
		}
		if ((bool)currentItemSelected && currentItemSelected.itemType == component.itemType && currentItemSelected.itemUniqueId == component.itemUniqueId)
		{
			component.SetColorItem(currentItemSelected.selectedColor);
			currentItemSelected = component;
		}
	}

	private void CreateItemSlotFloat(GameManager.PlayerData.CFloats ffloat, bool isEquiped = false)
	{
		SlotItem component = UnityEngine.Object.Instantiate(equipmentManager.slotItemPrefab, ItemsContainer).GetComponent<SlotItem>();
		component.transform.SetAsFirstSibling();
		component.itemType = GameManager.ItemType.Float;
		component.ffloat = ffloat;
		component.currentSlotIndex = currentSlotindex;
		component.Setup(itemType, ffloat.ID, ffloat.uniqueId, isEmpty: false, isEquiped);
		if (isEquiped)
		{
			component.itemStatusText.gameObject.SetActive(value: true);
			component.itemStatusText.text = LanguageManager.Instance.GetText("EQUIPPED").ToUpper();
			currentItemEquiped = component;
			component.deleteItemButton.gameObject.SetActive(value: false);
		}
		else
		{
			component.itemStatusText.gameObject.SetActive(value: false);
			component.deleteItemButton.gameObject.SetActive(value: true);
		}
		if ((bool)currentItemSelected && currentItemSelected.itemType == component.itemType && currentItemSelected.itemUniqueId == component.itemUniqueId)
		{
			component.SetColorItem(currentItemSelected.selectedColor);
			currentItemSelected = component;
		}
	}

	private void CreateItemSlotLeader(GameManager.PlayerData.CLeaders leader, bool isEquiped = false)
	{
		SlotItem component = UnityEngine.Object.Instantiate(equipmentManager.slotItemPrefab, ItemsContainer).GetComponent<SlotItem>();
		component.transform.SetAsFirstSibling();
		component.itemType = GameManager.ItemType.Leader;
		component.leader = leader;
		component.currentSlotIndex = currentSlotindex;
		component.Setup(itemType, leader.ID, leader.uniqueId, isEmpty: false, isEquiped);
		if (isEquiped)
		{
			component.itemStatusText.gameObject.SetActive(value: true);
			component.itemStatusText.text = LanguageManager.Instance.GetText("EQUIPPED").ToUpper();
			currentItemEquiped = component;
			component.deleteItemButton.gameObject.SetActive(value: false);
		}
		else
		{
			component.itemStatusText.gameObject.SetActive(value: false);
			component.deleteItemButton.gameObject.SetActive(value: true);
		}
		if ((bool)currentItemSelected && currentItemSelected.itemType == component.itemType && currentItemSelected.itemUniqueId == component.itemUniqueId)
		{
			component.SetColorItem(currentItemSelected.selectedColor);
			currentItemSelected = component;
		}
	}

	private void CreateItemSlotFeeder(GameManager.PlayerData.CFeeders feeder, bool isEquiped = false)
	{
		SlotItem component = UnityEngine.Object.Instantiate(equipmentManager.slotItemPrefab, ItemsContainer).GetComponent<SlotItem>();
		component.transform.SetAsFirstSibling();
		component.itemType = GameManager.ItemType.Feeder;
		component.feeder = feeder;
		component.currentSlotIndex = currentSlotindex;
		component.Setup(itemType, feeder.ID, feeder.uniqueId, isEmpty: false, isEquiped);
		if (isEquiped)
		{
			component.itemStatusText.gameObject.SetActive(value: true);
			component.itemStatusText.text = LanguageManager.Instance.GetText("EQUIPPED").ToUpper();
			currentItemEquiped = component;
			component.deleteItemButton.gameObject.SetActive(value: false);
		}
		else
		{
			component.itemStatusText.gameObject.SetActive(value: false);
			component.deleteItemButton.gameObject.SetActive(value: true);
		}
		if ((bool)currentItemSelected && currentItemSelected.itemType == component.itemType && currentItemSelected.itemUniqueId == component.itemUniqueId)
		{
			component.SetColorItem(currentItemSelected.selectedColor);
			currentItemSelected = component;
		}
	}

	private void CreateItemSlotHook(GameManager.PlayerData.CHooks hook, bool isEquiped = false)
	{
		SlotItem component = UnityEngine.Object.Instantiate(equipmentManager.slotItemPrefab, ItemsContainer).GetComponent<SlotItem>();
		component.transform.SetAsFirstSibling();
		component.itemType = GameManager.ItemType.Hook;
		component.hook = hook;
		component.currentSlotIndex = currentSlotindex;
		component.Setup(itemType, hook.ID, hook.uniqueId, isEmpty: false, isEquiped);
		if (isEquiped)
		{
			component.itemStatusText.gameObject.SetActive(value: true);
			component.itemStatusText.text = LanguageManager.Instance.GetText("EQUIPPED").ToUpper();
			currentItemEquiped = component;
			component.deleteItemButton.gameObject.SetActive(value: false);
		}
		else
		{
			component.itemStatusText.gameObject.SetActive(value: false);
			component.deleteItemButton.gameObject.SetActive(value: true);
		}
		if ((bool)currentItemSelected && currentItemSelected.itemType == component.itemType && currentItemSelected.itemUniqueId == component.itemUniqueId)
		{
			component.SetColorItem(currentItemSelected.selectedColor);
			currentItemSelected = component;
		}
	}

	private void CreateItemSlotBait(GameManager.PlayerData.CBaits bait, bool isEquiped = false, GameManager.GameBaits.Type baitType = GameManager.GameBaits.Type.Natural)
	{
		SlotItem component = UnityEngine.Object.Instantiate(equipmentManager.slotItemPrefab, ItemsContainer).GetComponent<SlotItem>();
		component.transform.SetAsFirstSibling();
		component.itemType = GameManager.ItemType.Bait;
		component.bait = bait;
		if (baitType == GameManager.GameBaits.Type.Natural)
		{
			component.isBaitNatural = true;
		}
		component.baitType = baitType;
		component.currentSlotIndex = currentSlotindex;
		component.Setup(itemType, bait.ID, bait.uniqueId, isEmpty: false, isEquiped);
		if (isEquiped)
		{
			component.itemStatusText.gameObject.SetActive(value: true);
			component.itemStatusText.text = LanguageManager.Instance.GetText("EQUIPPED").ToUpper();
			currentItemEquiped = component;
			component.deleteItemButton.gameObject.SetActive(value: false);
		}
		else
		{
			component.itemStatusText.gameObject.SetActive(value: false);
			component.deleteItemButton.gameObject.SetActive(value: true);
		}
		if ((bool)currentItemSelected && currentItemSelected.itemType == component.itemType && currentItemSelected.itemUniqueId == component.itemUniqueId)
		{
			component.SetColorItem(currentItemSelected.selectedColor);
			currentItemSelected = component;
		}
	}

	private void CreateItemSlotWeight(GameManager.PlayerData.CWeights weight, bool isEquiped = false)
	{
		SlotItem component = UnityEngine.Object.Instantiate(equipmentManager.slotItemPrefab, ItemsContainer).GetComponent<SlotItem>();
		component.transform.SetAsFirstSibling();
		component.itemType = GameManager.ItemType.Weight;
		component.weight = weight;
		component.currentSlotIndex = currentSlotindex;
		component.Setup(itemType, weight.ID, weight.uniqueId, isEmpty: false, isEquiped);
		if (isEquiped)
		{
			component.itemStatusText.gameObject.SetActive(value: true);
			component.itemStatusText.text = LanguageManager.Instance.GetText("EQUIPPED").ToUpper();
			currentItemEquiped = component;
			component.deleteItemButton.gameObject.SetActive(value: false);
		}
		else
		{
			component.itemStatusText.gameObject.SetActive(value: false);
			component.deleteItemButton.gameObject.SetActive(value: true);
		}
		if ((bool)currentItemSelected && currentItemSelected.itemType == component.itemType && currentItemSelected.itemUniqueId == component.itemUniqueId)
		{
			component.SetColorItem(currentItemSelected.selectedColor);
			currentItemSelected = component;
		}
	}

	private void CreateItemSlot(GameManager.ItemType itemType, int id, int uniqueIdItem, GameManager.GameBaits.Type baitType = GameManager.GameBaits.Type.Natural, bool isEquiped = false)
	{
		SlotItem component = UnityEngine.Object.Instantiate(equipmentManager.slotItemPrefab, ItemsContainer).GetComponent<SlotItem>();
		component.transform.SetAsFirstSibling();
		component.itemType = itemType;
		component.baitType = baitType;
		component.Setup(itemType, id, uniqueIdItem);
		if (isEquiped)
		{
			component.itemStatusText.gameObject.SetActive(value: true);
			component.itemStatusText.text = LanguageManager.Instance.GetText("EQUIPPED").ToUpper();
			currentItemEquiped = component;
			component.deleteItemButton.gameObject.SetActive(value: false);
			Debug.Log("Create item " + uniqueIdItem);
		}
		else
		{
			component.itemStatusText.gameObject.SetActive(value: false);
			component.deleteItemButton.gameObject.SetActive(value: true);
		}
		if ((bool)currentItemSelected && currentItemSelected.itemType == component.itemType && currentItemSelected.itemUniqueId == component.itemUniqueId)
		{
			component.SetColorItem(currentItemSelected.selectedColor);
			currentItemSelected = component;
		}
		if (itemType == GameManager.ItemType.Accesories)
		{
			int playerItemIndexByUniqueId = GameManager.Instance._playerData.GetPlayerItemIndexByUniqueId(GameManager.ItemType.Accesories, uniqueIdItem);
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[playerItemIndexByUniqueId].isUse)
			{
				component.deleteItemButton.gameObject.SetActive(value: false);
				component.itemStatusText.gameObject.SetActive(value: true);
				component.itemStatusText.text = LanguageManager.Instance.GetText("INUSE_SET").ToUpper();
				component.SetColorItem(component.equipedColor);
			}
			else
			{
				component.itemStatusText.gameObject.SetActive(value: false);
			}
		}
	}

	private void OnEnable()
	{
		currentItemSelected = null;
		equipmentManager = UnityEngine.Object.FindObjectOfType<EquipmentManager>();
		ItemsInfoContainer.gameObject.SetActive(value: false);
		ShowItemsFromSort("ALL");
		sortingTabsContents[(int)itemType].gameObject.SetActive(value: true);
	}

	private void OnDisable()
	{
		sortingTabsContents[(int)itemType].gameObject.SetActive(value: false);
		equipmentManager.slotButtons[5].GetComponent<Hover>().UnSelect();
	}

	public void SelectItem(int uniqueIdItem, SlotItem thisObject)
	{
		installSignalizerOptionsContent.gameObject.SetActive(value: false);
		if (currentItemEquiped == thisObject)
		{
			if (currentItemSelected != null)
			{
				currentItemSelected.SetColorItem(Color.white);
			}
			currentItemSelected = thisObject;
			currentItemSelected.SetColorItem(currentItemSelected.selectedColor);
			ShowItemDetails(uniqueIdItem);
			equipButton.SetActive(value: false);
			equipButtonBait.SetActive(value: false);
			unEquipButton.SetActive(value: false);
			unEquipButtonBait.SetActive(value: false);
			return;
		}
		if (currentItemSelected != null)
		{
			currentItemSelected.SetColorItem(Color.white);
		}
		currentItemSelected = thisObject;
		currentItemSelected.SetColorItem(currentItemSelected.selectedColor);
		ShowItemDetails(uniqueIdItem);
		equipButton.SetActive(value: true);
		equipButtonBait.SetActive(value: true);
		unEquipButton.SetActive(value: false);
		unEquipButtonBait.SetActive(value: false);
		if (itemType != GameManager.ItemType.Bait || uniqueIdItem <= -1)
		{
			return;
		}
		int iD = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].rod.ID;
		int gameItemIndexByItemId = GameManager.Instance._playerData.GetGameItemIndexByItemId(itemType, iD);
		if (GameManager.Instance.gameRods[gameItemIndexByItemId].type == GameManager.GameRods.Type.Spinning || GameManager.Instance.gameRods[gameItemIndexByItemId].type == GameManager.GameRods.Type.Casting)
		{
			GameManager.Instance._playerData.GetItemIdByUniqueId(itemType, uniqueIdItem);
			if (thisObject.baitType != GameManager.GameBaits.Type.Spinning)
			{
				equipButton.SetActive(value: false);
				equipButtonBait.SetActive(value: false);
			}
		}
		else if (GameManager.Instance.gameRods[gameItemIndexByItemId].type == GameManager.GameRods.Type.Universal)
		{
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].hook.isNull)
			{
				if (thisObject.baitType != GameManager.GameBaits.Type.Spinning)
				{
					equipButton.SetActive(value: false);
					equipButtonBait.SetActive(value: false);
				}
			}
			else if (thisObject.baitType != GameManager.GameBaits.Type.Natural)
			{
				equipButton.SetActive(value: false);
				equipButtonBait.SetActive(value: false);
			}
		}
		else if (thisObject.baitType != GameManager.GameBaits.Type.Natural)
		{
			equipButton.SetActive(value: false);
			equipButtonBait.SetActive(value: false);
		}
	}

	public void SelectItemAccesory(int uniqueIdItem, SlotItem thisObject)
	{
		int itemIdByUniqueId = GameManager.Instance._playerData.GetItemIdByUniqueId(GameManager.ItemType.Accesories, uniqueIdItem);
		int gameItemIndexByItemId = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Accesories, itemIdByUniqueId);
		installSignalizerOptionsContent.gameObject.SetActive(value: false);
		if (currentItemSelected != null)
		{
			currentItemSelected.SetColorItem(Color.white);
		}
		currentItemSelected = thisObject;
		currentItemSelected.SetColorItem(currentItemSelected.selectedColor);
		int playerItemIndexByUniqueId = GameManager.Instance._playerData.GetPlayerItemIndexByUniqueId(GameManager.ItemType.Accesories, uniqueIdItem);
		if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[playerItemIndexByUniqueId].isUse)
		{
			equipButtonBait.SetActive(value: false);
		}
		else
		{
			equipButton.SetActive(value: true);
			if (GameManager.Instance.gameAccesories[gameItemIndexByItemId].type == GameManager.GameAccesories.Type.RodSupport)
			{
				installSignalizerOptionsContent.gameId = itemIdByUniqueId;
				installSignalizerOptionsContent.playerUniqueId = uniqueIdItem;
				installSignalizerOptionsContent.playerIndexItem = playerItemIndexByUniqueId;
				installSignalizerOptionsContent.gameObject.SetActive(value: true);
			}
		}
		if (GameManager.Instance.gameAccesories[itemIdByUniqueId].type == GameManager.GameAccesories.Type.Signalizers)
		{
			equipButton.SetActive(value: false);
		}
		if (!FScriptsHandler.Instance)
		{
			equipButton.SetActive(value: false);
		}
		ShowItemDetails(uniqueIdItem);
	}

	private void ShowItemDetails(int uniqueIdItem)
	{
		if (uniqueIdItem == -1)
		{
			return;
		}
		int gameItemIndex = currentItemSelected.gameItemIndex;
		if (gameItemIndex == -1)
		{
			return;
		}
		switch (itemType)
		{
		case GameManager.ItemType.Rod:
		{
			ItemsInfoContainer.gameObject.SetActive(value: true);
			bigImage.sprite = GameManager.Instance.gameRods[gameItemIndex].GetIconImage();
			nameItemText.text = GameManager.Instance.gameRods[gameItemIndex].name;
			statsItemText.text = LanguageManager.Instance.GetText("TYPE") + ": " + GameManager.Instance.gameRods[gameItemIndex].type.ToString() + "\n";
			Text text = statsItemText;
			text.text = text.text + LanguageManager.Instance.GetText("STRENGTH") + ": " + GameManager.Instance.ConvertWeight(GameManager.Instance.gameRods[gameItemIndex].strength) + "\n";
			if (float.TryParse(GameManager.Instance.gameRods[gameItemIndex].length.Replace(',', '.'), out var result))
			{
				text = statsItemText;
				text.text = text.text + LanguageManager.Instance.GetText("LENGTH") + ": " + GameManager.Instance.ConvertLenghtWithUnit(result) + "\n";
			}
			text = statsItemText;
			text.text = text.text + LanguageManager.Instance.GetText("CW_ROD") + ": " + GameManager.Instance.ConvertWeightGramWithOz(GameManager.Instance.gameRods[gameItemIndex].cw.x) + " - " + GameManager.Instance.ConvertWeightGramWithOz(GameManager.Instance.gameRods[gameItemIndex].cw.y) + "\n";
			text = statsItemText;
			text.text = text.text + LanguageManager.Instance.GetText("LEVEL") + ": " + GameManager.Instance.gameRods[gameItemIndex].Level + "\n";
			text = statsItemText;
			text.text = text.text + LanguageManager.Instance.GetText("PRICE") + ": " + GameManager.Instance.gameRods[gameItemIndex].PriceNormal + "\n";
			if (GameManager.Instance.isDevModeAllowed)
			{
				int repairCost10 = GetRepairCost(uniqueIdItem, gameItemIndex);
				Text text10 = statsItemText;
				text10.text = text10.text + "[DevMode] Repair Cost: " + repairCost10 + " $";
			}
			descriptionItemText.text = GameManager.Instance.gameRods[gameItemIndex].GetDescription();
			if (!string.IsNullOrEmpty(GameManager.Instance.gameRods[gameItemIndex].logoBrandImagePath))
			{
				logoBrandImage.enabled = true;
				logoBrandImage.sprite = GameManager.Instance.gameRods[gameItemIndex].GetLogoBrandImage();
			}
			else
			{
				logoBrandImage.enabled = false;
			}
			break;
		}
		case GameManager.ItemType.Reel:
		{
			ItemsInfoContainer.gameObject.SetActive(value: true);
			bigImage.sprite = GameManager.Instance.gameReels[gameItemIndex].GetIconImage();
			nameItemText.text = GameManager.Instance.gameReels[gameItemIndex].name;
			statsItemText.text = LanguageManager.Instance.GetText("TYPE") + ": " + GameManager.Instance.gameReels[gameItemIndex].type.ToString() + "\n";
			Text text = statsItemText;
			text.text = text.text + LanguageManager.Instance.GetText("STRENGTH") + ": " + GameManager.Instance.ConvertWeight(GameManager.Instance.gameReels[gameItemIndex].strength) + "\n";
			text = statsItemText;
			text.text = text.text + LanguageManager.Instance.GetText("LEVEL") + ": " + GameManager.Instance.gameReels[gameItemIndex].Level + "\n";
			text = statsItemText;
			text.text = text.text + LanguageManager.Instance.GetText("PRICE") + ": " + GameManager.Instance.gameReels[gameItemIndex].PriceNormal + "\n";
			if (GameManager.Instance.isDevModeAllowed)
			{
				int repairCost4 = GetRepairCost(uniqueIdItem, gameItemIndex);
				Text text5 = statsItemText;
				text5.text = text5.text + "[DevMode] Repair Cost: " + repairCost4 + " $";
			}
			descriptionItemText.text = GameManager.Instance.gameReels[gameItemIndex].GetDescription();
			if (!string.IsNullOrEmpty(GameManager.Instance.gameReels[gameItemIndex].logoBrandImagePath))
			{
				logoBrandImage.enabled = true;
				logoBrandImage.sprite = GameManager.Instance.gameReels[gameItemIndex].GetLogoBrandImage();
			}
			else
			{
				logoBrandImage.enabled = false;
			}
			break;
		}
		case GameManager.ItemType.Line:
		{
			ItemsInfoContainer.gameObject.SetActive(value: true);
			bigImage.sprite = GameManager.Instance.gameLines[gameItemIndex].GetIconImage();
			nameItemText.text = GameManager.Instance.gameLines[gameItemIndex].name;
			statsItemText.text = LanguageManager.Instance.GetText("TYPE") + ": " + GameManager.Instance.gameLines[gameItemIndex].type.ToString() + "\n";
			Text text = statsItemText;
			text.text = text.text + LanguageManager.Instance.GetText("SIZE") + ": " + GameManager.Instance.gameLines[gameItemIndex].size + " mm\n";
			text = statsItemText;
			text.text = text.text + LanguageManager.Instance.GetText("STRENGTH") + ": " + GameManager.Instance.ConvertWeight(GameManager.Instance.gameLines[gameItemIndex].strength) + "\n";
			text = statsItemText;
			text.text = text.text + LanguageManager.Instance.GetText("LEVEL") + ": " + GameManager.Instance.gameLines[gameItemIndex].Level + "\n";
			text = statsItemText;
			text.text = text.text + LanguageManager.Instance.GetText("PRICE") + ": " + GameManager.Instance.gameLines[gameItemIndex].PriceNormal + "\n";
			if (GameManager.Instance.isDevModeAllowed)
			{
				int repairCost2 = GetRepairCost(uniqueIdItem, gameItemIndex);
				Text text3 = statsItemText;
				text3.text = text3.text + "[DevMode] Repair Cost: " + repairCost2 + " $";
			}
			descriptionItemText.text = GameManager.Instance.gameLines[gameItemIndex].GetDescription();
			if (!string.IsNullOrEmpty(GameManager.Instance.gameLines[gameItemIndex].logoBrandImagePath))
			{
				logoBrandImage.enabled = true;
				logoBrandImage.sprite = GameManager.Instance.gameLines[gameItemIndex].GetLogoBrandImage();
			}
			else
			{
				logoBrandImage.enabled = false;
			}
			break;
		}
		case GameManager.ItemType.Float:
		{
			ItemsInfoContainer.gameObject.SetActive(value: true);
			bigImage.sprite = GameManager.Instance.gameFloats[gameItemIndex].GetIconImage();
			nameItemText.text = GameManager.Instance.gameFloats[gameItemIndex].name;
			statsItemText.text = LanguageManager.Instance.GetText("TYPE") + ": " + GameManager.Instance.gameFloats[gameItemIndex].type.ToString() + "\n";
			statsItemText.text = LanguageManager.Instance.GetText("DISPLACEMENT") + ": " + GameManager.Instance.ConvertWeightGramWithOz(GameManager.Instance.gameFloats[gameItemIndex].displacement) + "\n";
			Text text = statsItemText;
			text.text = text.text + LanguageManager.Instance.GetText("LEVEL") + ": " + GameManager.Instance.gameFloats[gameItemIndex].Level + "\n";
			text = statsItemText;
			text.text = text.text + LanguageManager.Instance.GetText("PRICE") + ": " + GameManager.Instance.gameFloats[gameItemIndex].PriceNormal + "\n";
			if (GameManager.Instance.isDevModeAllowed)
			{
				int repairCost9 = GetRepairCost(uniqueIdItem, gameItemIndex);
				Text text9 = statsItemText;
				text9.text = text9.text + "[DevMode] Repair Cost: " + repairCost9 + " $";
			}
			descriptionItemText.text = GameManager.Instance.gameFloats[gameItemIndex].GetDescription();
			if (!string.IsNullOrEmpty(GameManager.Instance.gameFloats[gameItemIndex].logoBrandImagePath))
			{
				logoBrandImage.enabled = true;
				logoBrandImage.sprite = GameManager.Instance.gameFloats[gameItemIndex].GetLogoBrandImage();
			}
			else
			{
				logoBrandImage.enabled = false;
			}
			break;
		}
		case GameManager.ItemType.Hook:
		{
			ItemsInfoContainer.gameObject.SetActive(value: true);
			bigImage.sprite = GameManager.Instance.gameHooks[gameItemIndex].GetIconImage();
			nameItemText.text = GameManager.Instance.gameHooks[gameItemIndex].GetName();
			statsItemText.text = LanguageManager.Instance.GetText("TYPE") + ": " + GameManager.Instance.gameHooks[gameItemIndex].type.ToString() + "\n";
			Text text = statsItemText;
			text.text = text.text + LanguageManager.Instance.GetText("SIZE") + ": " + GameManager.Instance.gameHooks[gameItemIndex].GetSizetext() + "\n";
			text = statsItemText;
			text.text = text.text + LanguageManager.Instance.GetText("COLOR") + ": " + LanguageManager.Instance.GetText(GameManager.Instance.gameHooks[gameItemIndex].color.ToString().ToUpper() + "_COLOR") + "\n";
			text = statsItemText;
			text.text = text.text + LanguageManager.Instance.GetText("LEVEL") + ": " + GameManager.Instance.gameHooks[gameItemIndex].Level + "\n";
			text = statsItemText;
			text.text = text.text + LanguageManager.Instance.GetText("PRICE") + ": " + GameManager.Instance.gameHooks[gameItemIndex].PriceNormal + "\n";
			if (GameManager.Instance.isDevModeAllowed)
			{
				int repairCost8 = GetRepairCost(uniqueIdItem, gameItemIndex);
				Text text8 = statsItemText;
				text8.text = text8.text + "[DevMode] Repair Cost: " + repairCost8 + " $";
			}
			descriptionItemText.text = GameManager.Instance.gameHooks[gameItemIndex].GetDescription();
			if (!string.IsNullOrEmpty(GameManager.Instance.gameHooks[gameItemIndex].logoBrandImagePath))
			{
				logoBrandImage.enabled = true;
				logoBrandImage.sprite = GameManager.Instance.gameHooks[gameItemIndex].GetLogoBrandImage();
			}
			else
			{
				logoBrandImage.enabled = false;
			}
			break;
		}
		case GameManager.ItemType.Bait:
		{
			ItemsInfoContainerBait.gameObject.SetActive(value: true);
			bigImageBait.sprite = GameManager.Instance.gameBaits[gameItemIndex].GetIconImage();
			nameItemTextBait.text = GameManager.Instance.gameBaits[gameItemIndex].GetName();
			TypeTextBait.text = LanguageManager.Instance.GetText("TYPE") + ": " + LanguageManager.Instance.GetText(GameManager.Instance.gameBaits[gameItemIndex].type.ToString().ToUpper() + "_TYPE") + "\n";
			LevelTextBait.text = LanguageManager.Instance.GetText("LEVEL") + ": " + GameManager.Instance.gameBaits[gameItemIndex].Level + "\n";
			if (GameManager.Instance.gameBaits[gameItemIndex].type == GameManager.GameBaits.Type.Spinning)
			{
				WeightTextBait.text = LanguageManager.Instance.GetText("WEIGHT") + ": " + GameManager.Instance.gameBaits[gameItemIndex].weight + " g\n";
			}
			else
			{
				WeightTextBait.text = "";
			}
			if (GameManager.Instance.isDevModeAllowed)
			{
				int repairCost5 = GetRepairCost(uniqueIdItem, gameItemIndex);
				Text weightTextBait = WeightTextBait;
				weightTextBait.text = weightTextBait.text + "[DevMode] Repair Cost: " + repairCost5 + " $";
			}
			descriptionItemTextBait.text = GameManager.Instance.gameBaits[gameItemIndex].GetDescription();
			if (!string.IsNullOrEmpty(GameManager.Instance.gameBaits[gameItemIndex].logoBrandImagePath))
			{
				logoBrandImageBait.enabled = true;
				logoBrandImageBait.sprite = GameManager.Instance.gameBaits[gameItemIndex].GetLogoBrandImage();
			}
			else
			{
				logoBrandImageBait.enabled = false;
			}
			GameManager.TruncateContainer(TakingFishBaitContainer);
			FishListItemScrollBar.value = 1f;
			List<GameManager.GameFish> list = new List<GameManager.GameFish>();
			if (GameManager.Instance.gameBaits[gameItemIndex].type == GameManager.GameBaits.Type.Spinning)
			{
				for (int i = 0; i < GameManager.Instance.gameFish.Length; i++)
				{
					for (int j = 0; j < GameManager.Instance.gameFish[i].acceptFishLures.Count; j++)
					{
						if (GameManager.Instance.gameFish[i].acceptFishLures[j].baitId == GameManager.Instance.gameBaits[gameItemIndex].id)
						{
							list.Add(GameManager.Instance.gameFish[i]);
						}
					}
				}
			}
			else
			{
				for (int k = 0; k < GameManager.Instance.gameFish.Length; k++)
				{
					for (int l = 0; l < GameManager.Instance.gameFish[k].acceptFishBaits.Count; l++)
					{
						if (GameManager.Instance.gameFish[k].acceptFishBaits[l].baitId == GameManager.Instance.gameBaits[gameItemIndex].id)
						{
							list.Add(GameManager.Instance.gameFish[k]);
						}
					}
				}
			}
			GameManager.GameFish[] array = list.OrderBy((GameManager.GameFish fish) => fish.GetFishName()).ToArray();
			List<GameManager.GameFish> list2 = new List<GameManager.GameFish>();
			if ((bool)FScriptsHandler.Instance)
			{
				int sceneID = FScriptsHandler.Instance.m_SceneSettings.sceneID;
				for (int num = 0; num < GameManager.Instance.gameLocations.Length; num++)
				{
					if (GameManager.Instance.gameLocations[num].sceneID != sceneID)
					{
						continue;
					}
					for (int num2 = 0; num2 < GameManager.Instance.gameLocations[num].fishSpecies.Length; num2++)
					{
						for (int num3 = 0; num3 < array.Length; num3++)
						{
							if (array[num3].speciesName == GameManager.Instance.gameLocations[num].fishSpecies[num2])
							{
								list2.Add(array[num3]);
							}
						}
					}
				}
				array = list2.ToArray();
			}
			if (array.Length == 0)
			{
				takesOnTextBait.text = "";
				NoneFishTextBait.text = LanguageManager.Instance.GetText("NO_FISH_IN_LIST");
			}
			else
			{
				takesOnTextBait.text = LanguageManager.Instance.GetText("TAKES_ON");
				NoneFishTextBait.text = "";
			}
			array = array.OrderBy((GameManager.GameFish fish) => fish.GetFishName()).ToArray();
			for (int num4 = 0; num4 < array.Length; num4++)
			{
				BaitFishListItem component = UnityEngine.Object.Instantiate(FishListItemPrefab, TakingFishBaitContainer).GetComponent<BaitFishListItem>();
				component.fishName = array[num4].GetFishName();
				component.fishIcon = array[num4].GetFishIcon(10f);
			}
			break;
		}
		case GameManager.ItemType.Feeder:
		{
			ItemsInfoContainer.gameObject.SetActive(value: true);
			bigImage.sprite = GameManager.Instance.gameFeeders[gameItemIndex].GetIconImage();
			nameItemText.text = GameManager.Instance.gameFeeders[gameItemIndex].name;
			statsItemText.text = LanguageManager.Instance.GetText("TYPE") + ": " + GameManager.Instance.gameFeeders[gameItemIndex].type.ToString() + "\n";
			Text text = statsItemText;
			text.text = text.text + LanguageManager.Instance.GetText("LEVEL") + ": " + GameManager.Instance.gameFeeders[gameItemIndex].Level + "\n";
			text = statsItemText;
			text.text = text.text + LanguageManager.Instance.GetText("PRICE") + ": " + GameManager.Instance.gameFeeders[gameItemIndex].PriceNormal + "\n";
			if (GameManager.Instance.isDevModeAllowed)
			{
				int repairCost7 = GetRepairCost(uniqueIdItem, gameItemIndex);
				Text text7 = statsItemText;
				text7.text = text7.text + "[DevMode] Repair Cost: " + repairCost7 + " $";
			}
			descriptionItemText.text = GameManager.Instance.gameFeeders[gameItemIndex].GetDescription();
			if (!string.IsNullOrEmpty(GameManager.Instance.gameFeeders[gameItemIndex].logoBrandImagePath))
			{
				logoBrandImage.enabled = true;
				logoBrandImage.sprite = GameManager.Instance.gameFeeders[gameItemIndex].GetLogoBrandImage();
			}
			else
			{
				logoBrandImage.enabled = false;
			}
			break;
		}
		case GameManager.ItemType.Leader:
		{
			ItemsInfoContainer.gameObject.SetActive(value: true);
			bigImage.sprite = GameManager.Instance.gameLeaders[gameItemIndex].GetIconImage();
			nameItemText.text = GameManager.Instance.gameLeaders[gameItemIndex].GetName();
			statsItemText.text = LanguageManager.Instance.GetText("TYPE") + ": " + GameManager.Instance.gameLeaders[gameItemIndex].type.ToString() + "\n";
			Text text = statsItemText;
			text.text = text.text + LanguageManager.Instance.GetText("STRENGTH") + ": " + GameManager.Instance.ConvertWeight(GameManager.Instance.gameLeaders[gameItemIndex].strength) + "\n";
			text = statsItemText;
			text.text = text.text + LanguageManager.Instance.GetText("LEVEL") + ": " + GameManager.Instance.gameLeaders[gameItemIndex].Level + "\n";
			text = statsItemText;
			text.text = text.text + LanguageManager.Instance.GetText("PRICE") + ": " + GameManager.Instance.gameLeaders[gameItemIndex].PriceNormal + "\n";
			if (GameManager.Instance.isDevModeAllowed)
			{
				int repairCost3 = GetRepairCost(uniqueIdItem, gameItemIndex);
				Text text4 = statsItemText;
				text4.text = text4.text + "[DevMode] Repair Cost: " + repairCost3 + " $";
			}
			descriptionItemText.text = GameManager.Instance.gameLeaders[gameItemIndex].GetDescription();
			if (!string.IsNullOrEmpty(GameManager.Instance.gameLeaders[gameItemIndex].logoBrandImagePath))
			{
				logoBrandImage.enabled = true;
				logoBrandImage.sprite = GameManager.Instance.gameLeaders[gameItemIndex].GetLogoBrandImage();
			}
			else
			{
				logoBrandImage.enabled = false;
			}
			break;
		}
		case GameManager.ItemType.Weight:
		{
			ItemsInfoContainer.gameObject.SetActive(value: true);
			bigImage.sprite = GameManager.Instance.gameWeights[gameItemIndex].GetIconImage();
			nameItemText.text = GameManager.Instance.gameWeights[gameItemIndex].GetName();
			statsItemText.text = LanguageManager.Instance.GetText("ITEM_WEIGHT") + ": " + GameManager.Instance.ConvertWeightGramWithOz(GameManager.Instance.gameWeights[gameItemIndex].weight) + "\n";
			Text text = statsItemText;
			text.text = text.text + LanguageManager.Instance.GetText("LEVEL") + ": " + GameManager.Instance.gameWeights[gameItemIndex].Level + "\n";
			text = statsItemText;
			text.text = text.text + LanguageManager.Instance.GetText("PRICE") + ": " + GameManager.Instance.gameWeights[gameItemIndex].PriceNormal + "\n";
			if (GameManager.Instance.isDevModeAllowed)
			{
				int repairCost6 = GetRepairCost(uniqueIdItem, gameItemIndex);
				Text text6 = statsItemText;
				text6.text = text6.text + "[DevMode] Repair Cost: " + repairCost6 + " $";
			}
			descriptionItemText.text = GameManager.Instance.gameWeights[gameItemIndex].GetDescription();
			if (!string.IsNullOrEmpty(GameManager.Instance.gameWeights[gameItemIndex].logoBrandImagePath))
			{
				logoBrandImage.enabled = true;
				logoBrandImage.sprite = GameManager.Instance.gameWeights[gameItemIndex].GetLogoBrandImage();
			}
			else
			{
				logoBrandImage.enabled = false;
			}
			break;
		}
		case GameManager.ItemType.Accesories:
		{
			ItemsInfoContainer.gameObject.SetActive(value: true);
			bigImage.sprite = GameManager.Instance.gameAccesories[gameItemIndex].GetIconImage();
			nameItemText.text = GameManager.Instance.gameAccesories[gameItemIndex].GetName();
			statsItemText.text = LanguageManager.Instance.GetText("LEVEL") + ": " + GameManager.Instance.gameAccesories[gameItemIndex].Level + "\n";
			Text text = statsItemText;
			text.text = text.text + LanguageManager.Instance.GetText("PRICE") + ": " + GameManager.Instance.gameAccesories[gameItemIndex].PriceNormal + "\n";
			if (GameManager.Instance.isDevModeAllowed)
			{
				int repairCost = GetRepairCost(uniqueIdItem, gameItemIndex);
				Text text2 = statsItemText;
				text2.text = text2.text + "[DevMode] Repair Cost: " + repairCost + " $";
			}
			descriptionItemText.text = GameManager.Instance.gameAccesories[gameItemIndex].GetDescription();
			if (!string.IsNullOrEmpty(GameManager.Instance.gameAccesories[gameItemIndex].logoBrandImagePath))
			{
				logoBrandImage.enabled = true;
				logoBrandImage.sprite = GameManager.Instance.gameAccesories[gameItemIndex].GetLogoBrandImage();
			}
			else
			{
				logoBrandImage.enabled = false;
			}
			break;
		}
		}
		int repairCost11 = GetRepairCost(uniqueIdItem, gameItemIndex);
		if (repairCost11 > 0)
		{
			repairButton.SetActive(value: true);
			reapairCost.text = "$ " + repairCost11;
		}
		else if (repairCost11 == -1)
		{
			repairButton.SetActive(value: true);
			reapairCost.text = "$ 0";
		}
		else
		{
			repairButton.SetActive(value: false);
		}
		repairButtonBait.SetActive(value: false);
		Debug.Log("Reperuj " + repairCost11);
	}

	private bool FishOnMap(GameManager.GameFish[] list, GameManager.FishSpecies species)
	{
		for (int i = 0; i < list.Length; i++)
		{
			if (list[i].speciesName == species)
			{
				return true;
			}
		}
		return false;
	}

	private int GetRepairCost(int uniqueIdItem, int itemGameIndex)
	{
		int num = 0;
		switch (itemType)
		{
		case GameManager.ItemType.Rod:
		{
			for (int k = 0; k < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods.Count; k++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[k].uniqueId == uniqueIdItem && Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[k].wear < 100)
				{
					float price3 = GameManager.Instance.gameRods[itemGameIndex].GetPrice();
					num = ((price3 == 0f) ? (-1) : ((int)(price3 * 0.15f)));
				}
			}
			for (int l = 0; l < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip.Count; l++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[l].rod.uniqueId == uniqueIdItem && Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[l].rod.wear < 100)
				{
					int indexByItemId = GameManager.Instance.GetIndexByItemId(GameManager.ItemType.Rod, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[l].rod.ID);
					float price4 = GameManager.Instance.gameRods[indexByItemId].GetPrice();
					num = ((price4 == 0f) ? (-1) : ((int)(price4 * 0.15f)));
				}
			}
			break;
		}
		case GameManager.ItemType.Reel:
		{
			for (int i = 0; i < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels.Count; i++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[i].uniqueId == uniqueIdItem && Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[i].wear < 100)
				{
					float price = GameManager.Instance.gameReels[itemGameIndex].GetPrice();
					num = ((price == 0f) ? (-1) : ((int)(price * 0.15f)));
				}
			}
			for (int j = 0; j < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip.Count; j++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[j].reel.uniqueId == uniqueIdItem && Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[j].reel.wear < 100)
				{
					float price2 = GameManager.Instance.gameReels[itemGameIndex].GetPrice();
					num = ((price2 == 0f) ? (-1) : ((int)(price2 * 0.15f)));
				}
			}
			break;
		}
		}
		if (num > 0 && Singleton<SaveDataManager>.Instance.HasCurrentPlayerSkill(GameManager.Skills.free_repair))
		{
			num -= Mathf.CeilToInt((float)num * 0.5f);
		}
		return num;
	}

	public void Repair()
	{
		int itemGameIndex = 0;
		int itemIdByUniqueId = GameManager.Instance._playerData.GetItemIdByUniqueId(itemType, currentItemSelected.itemUniqueId);
		if (itemIdByUniqueId != -1)
		{
			itemGameIndex = GameManager.Instance._playerData.GetGameItemIndexByItemId(itemType, itemIdByUniqueId);
		}
		else
		{
			if (itemType == GameManager.ItemType.Rod)
			{
				itemGameIndex = GameManager.Instance._playerData.GetGameItemIndexByItemId(itemType, currentItemSelected.rod.ID);
			}
			if (itemType == GameManager.ItemType.Reel)
			{
				itemGameIndex = GameManager.Instance._playerData.GetGameItemIndexByItemId(itemType, currentItemSelected.reel.ID);
			}
		}
		int repairCost = GetRepairCost(currentItemSelected.itemUniqueId, itemGameIndex);
		if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerCash < (float)repairCost && !Singleton<SaveDataManager>.Instance.IsCurrentlySandbox())
		{
			GameManager.Instance.ShowMessagePopup(LanguageManager.Instance.GetText("CASH_OUT_REPAIR"), equipmentManager.GetComponent<Canvas>().transform);
			return;
		}
		switch (itemType)
		{
		case GameManager.ItemType.Rod:
		{
			for (int k = 0; k < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods.Count; k++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[k].uniqueId == currentItemSelected.itemUniqueId)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[k].wear = 100;
				}
			}
			for (int l = 0; l < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip.Count; l++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[l].rod.uniqueId == currentItemSelected.itemUniqueId)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[l].rod.wear = 100;
				}
			}
			break;
		}
		case GameManager.ItemType.Reel:
		{
			for (int i = 0; i < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels.Count; i++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[i].uniqueId == currentItemSelected.itemUniqueId)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[i].wear = 100;
				}
			}
			for (int j = 0; j < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip.Count; j++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[j].reel.uniqueId == currentItemSelected.itemUniqueId)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[j].reel.wear = 100;
				}
			}
			break;
		}
		}
		EquipPopup.OnItemRepairGlobal?.Invoke();
		if (repairCost > 0)
		{
			GameManager.Instance._playerData.AddSubPlayerCashValue(-repairCost);
		}
		currentItemSelected.damageSignImage.gameObject.SetActive(value: false);
		equipmentManager.checkAndShowDamageSignSlot();
		repairButton.SetActive(value: false);
		repairButtonBait.SetActive(value: false);
		RefreshSort();
	}

	private bool CheckIsItemEquiped(GameManager.ItemType itemType, int uniqueIdItem)
	{
		for (int i = 0; i < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip.Count; i++)
		{
			switch (itemType)
			{
			case GameManager.ItemType.Rod:
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[i].rod.uniqueId == uniqueIdItem)
				{
					return true;
				}
				break;
			case GameManager.ItemType.Reel:
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[i].reel.uniqueId == uniqueIdItem)
				{
					return true;
				}
				break;
			case GameManager.ItemType.Line:
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[i].line.uniqueId == uniqueIdItem)
				{
					return true;
				}
				break;
			case GameManager.ItemType.Float:
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[i].ffloat.uniqueId == uniqueIdItem)
				{
					return true;
				}
				break;
			case GameManager.ItemType.Leader:
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[i].leader.uniqueId == uniqueIdItem)
				{
					return true;
				}
				break;
			case GameManager.ItemType.Feeder:
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[i].feeder.uniqueId == uniqueIdItem)
				{
					return true;
				}
				break;
			case GameManager.ItemType.Hook:
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[i].hook.uniqueId == uniqueIdItem)
				{
					return true;
				}
				break;
			case GameManager.ItemType.Bait:
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[i].bait.uniqueId == uniqueIdItem)
				{
					return true;
				}
				break;
			case GameManager.ItemType.Weight:
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[i].weight.uniqueId == uniqueIdItem)
				{
					return true;
				}
				break;
			}
		}
		return false;
	}

	private bool ValidateRodByReelTypes(int newRodId)
	{
		if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].reel.isNull)
		{
			return true;
		}
		int indexByItemId = GameManager.Instance.GetIndexByItemId(GameManager.ItemType.Rod, newRodId);
		int indexByItemId2 = GameManager.Instance.GetIndexByItemId(GameManager.ItemType.Reel, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].reel.ID);
		if (GameManager.Instance.gameRods[indexByItemId].type == GameManager.GameRods.Type.Casting)
		{
			if (GameManager.Instance.gameReels[indexByItemId2].type == GameManager.GameReels.Type.Casting)
			{
				return true;
			}
			return false;
		}
		if (GameManager.Instance.gameReels[indexByItemId2].type == GameManager.GameReels.Type.Casting)
		{
			return false;
		}
		return true;
	}

	private bool ValidateReelByRodTypes(int newReelId)
	{
		if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].rod.isNull)
		{
			return true;
		}
		int indexByItemId = GameManager.Instance.GetIndexByItemId(GameManager.ItemType.Rod, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].rod.ID);
		int indexByItemId2 = GameManager.Instance.GetIndexByItemId(GameManager.ItemType.Reel, newReelId);
		if (GameManager.Instance.gameReels[indexByItemId2].type == GameManager.GameReels.Type.Casting)
		{
			if (GameManager.Instance.gameRods[indexByItemId].type == GameManager.GameRods.Type.Casting)
			{
				return true;
			}
			return false;
		}
		if (GameManager.Instance.gameRods[indexByItemId].type == GameManager.GameRods.Type.Casting)
		{
			return false;
		}
		return true;
	}

	public void Equip()
	{
		EquipPopup.OnItemEquipGlobal?.Invoke();
		switch (itemType)
		{
		case GameManager.ItemType.Rod:
		{
			for (int m = 0; m < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods.Count; m++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[m].uniqueId != currentItemSelected.itemUniqueId)
				{
					continue;
				}
				if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].rod.isNull)
				{
					int indexByItemId = GameManager.Instance.GetIndexByItemId(GameManager.ItemType.Rod, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].rod.ID);
					int indexByItemId2 = GameManager.Instance.GetIndexByItemId(GameManager.ItemType.Rod, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[m].ID);
					if (GameManager.Instance.gameRods[indexByItemId].type != GameManager.Instance.gameRods[indexByItemId2].type)
					{
						if (!ValidateRodByReelTypes(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[m].ID))
						{
							UnEquip(GameManager.ItemType.Reel);
						}
						UnEquip(GameManager.ItemType.Float);
						UnEquip(GameManager.ItemType.Feeder);
						UnEquip(GameManager.ItemType.Weight);
						UnEquip(GameManager.ItemType.Hook);
						UnEquip(GameManager.ItemType.Bait);
						Debug.Log("Unequip all");
					}
				}
				UnEquip(GameManager.ItemType.Rod);
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].rod.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[m]);
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].rod.amount = 1;
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[m].amount--;
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[m].amount <= 0)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods.Remove(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[m]);
				}
				equipmentManager.HidePopupByBtn();
			}
			break;
		}
		case GameManager.ItemType.Reel:
		{
			for (int num3 = 0; num3 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels.Count; num3++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num3].uniqueId == currentItemSelected.itemUniqueId)
				{
					if (!ValidateReelByRodTypes(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num3].ID))
					{
						Debug.Log("Nie odpowiedni typ wedki do wybranego kolowrotka");
						GameManager.Instance.ShowMessagePopup(LanguageManager.Instance.GetText("REEL_TYPE_INVALID"), equipmentManager.GetComponent<Canvas>().transform);
						return;
					}
					UnEquip(GameManager.ItemType.Reel);
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].reel.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num3]);
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].reel.amount = 1;
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num3].amount--;
					if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num3].amount <= 0)
					{
						Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels.Remove(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num3]);
					}
					equipmentManager.HidePopupByBtn();
				}
			}
			break;
		}
		case GameManager.ItemType.Line:
		{
			UnEquip(GameManager.ItemType.Line);
			for (int j = 0; j < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines.Count; j++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[j].uniqueId == currentItemSelected.itemUniqueId)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].line.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[j]);
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].line.amount = 1;
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[j].amount--;
					if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[j].amount <= 0)
					{
						Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines.Remove(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[j]);
					}
					equipmentManager.HidePopupByBtn();
				}
			}
			break;
		}
		case GameManager.ItemType.Float:
		{
			UnEquip(GameManager.ItemType.Float);
			for (int num = 0; num < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats.Count; num++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[num].uniqueId == currentItemSelected.itemUniqueId)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].ffloat.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[num]);
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].ffloat.amount = 1;
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[num].amount--;
					if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[num].amount <= 0)
					{
						Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats.Remove(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[num]);
					}
					equipmentManager.HidePopupByBtn();
				}
			}
			break;
		}
		case GameManager.ItemType.Hook:
		{
			UnEquip(GameManager.ItemType.Hook);
			for (int k = 0; k < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks.Count; k++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[k].uniqueId == currentItemSelected.itemUniqueId)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].hook.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[k]);
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].hook.amount = 1;
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[k].amount--;
					if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[k].amount <= 0)
					{
						Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks.Remove(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[k]);
					}
					equipmentManager.HidePopupByBtn();
				}
			}
			break;
		}
		case GameManager.ItemType.Bait:
		{
			UnEquip(GameManager.ItemType.Bait);
			for (int num4 = 0; num4 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits.Count; num4++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[num4].uniqueId == currentItemSelected.itemUniqueId)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].bait.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[num4]);
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].bait.amount = 1;
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[num4].amount--;
					if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[num4].amount <= 0)
					{
						Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits.Remove(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[num4]);
					}
					equipmentManager.HidePopupByBtn();
				}
			}
			break;
		}
		case GameManager.ItemType.Feeder:
		{
			UnEquip(GameManager.ItemType.Feeder);
			for (int num2 = 0; num2 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders.Count; num2++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[num2].uniqueId == currentItemSelected.itemUniqueId)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].feeder.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[num2]);
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].feeder.amount = 1;
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[num2].amount--;
					if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[num2].amount <= 0)
					{
						Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders.Remove(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[num2]);
					}
					equipmentManager.HidePopupByBtn();
				}
			}
			break;
		}
		case GameManager.ItemType.Leader:
		{
			UnEquip(GameManager.ItemType.Leader);
			for (int n = 0; n < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders.Count; n++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[n].uniqueId == currentItemSelected.itemUniqueId)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].leader.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[n]);
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].leader.amount = 1;
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[n].amount--;
					if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[n].amount <= 0)
					{
						Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders.Remove(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[n]);
					}
					equipmentManager.HidePopupByBtn();
				}
			}
			break;
		}
		case GameManager.ItemType.Weight:
		{
			UnEquip(GameManager.ItemType.Weight);
			for (int l = 0; l < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights.Count; l++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[l].uniqueId == currentItemSelected.itemUniqueId)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].weight.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[l]);
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].weight.amount = 1;
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[l].amount--;
					if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[l].amount <= 0)
					{
						Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights.Remove(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[l]);
					}
					equipmentManager.HidePopupByBtn();
				}
			}
			break;
		}
		case GameManager.ItemType.Accesories:
		{
			if (!FScriptsHandler.Instance)
			{
				return;
			}
			for (int i = 0; i < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories.Count; i++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[i].uniqueId == currentItemSelected.itemUniqueId)
				{
					if ((bool)FScriptsHandler.Instance.m_PlayerMain.currentRod)
					{
						GameManager.Instance.ShowMessagePopup(LanguageManager.Instance.GetText("CANT_USE_ITEM_BY_ROD"), UnityEngine.Object.FindObjectOfType<EquipmentManager>().GetComponent<Canvas>().transform);
					}
					else if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[i].isUse)
					{
						Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[i].isUse = true;
						FScriptsHandler.Instance.m_InventoryManager.assignAccesoryId = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[i].ID;
						FScriptsHandler.Instance.m_InventoryManager.assignAccesoryUniqueID = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[i].uniqueId;
						Debug.Log("Use accesoty id: " + currentItemSelected.itemUniqueId);
						GameManager.Instance.UnloadAddectiveScene();
					}
				}
			}
			break;
		}
		}
		equipmentManager.ShowRefreshItems();
	}

	public void UnEquipButton(GameManager.ItemType itemtype)
	{
		UnEquip(itemType);
		if (itemType == GameManager.ItemType.Rod)
		{
			UnEquip(GameManager.ItemType.Reel);
			UnEquip(GameManager.ItemType.Float);
			UnEquip(GameManager.ItemType.Feeder);
			UnEquip(GameManager.ItemType.Weight);
			UnEquip(GameManager.ItemType.Hook);
			UnEquip(GameManager.ItemType.Line);
			UnEquip(GameManager.ItemType.Bait);
			UnEquip(GameManager.ItemType.Leader);
		}
		else if (itemType == GameManager.ItemType.Reel)
		{
			UnEquip(GameManager.ItemType.Float);
			UnEquip(GameManager.ItemType.Feeder);
			UnEquip(GameManager.ItemType.Weight);
			UnEquip(GameManager.ItemType.Hook);
			UnEquip(GameManager.ItemType.Line);
			UnEquip(GameManager.ItemType.Bait);
			UnEquip(GameManager.ItemType.Leader);
		}
		equipmentManager.HidePopupByBtn();
	}

	private void UnEquip(GameManager.ItemType itemTypeS)
	{
		switch (itemTypeS)
		{
		case GameManager.ItemType.Rod:
		{
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].rod.isNull)
			{
				break;
			}
			for (int num = 0; num < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods.Count; num++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num].ID == Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].rod.ID && Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num].wear == Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].rod.wear)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].rod.SetToNull();
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num].amount++;
					return;
				}
			}
			GameManager.PlayerData.CRods cRods = new GameManager.PlayerData.CRods();
			cRods.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].rod);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods.Add(cRods);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].rod.SetToNull();
			break;
		}
		case GameManager.ItemType.Reel:
		{
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].reel.isNull)
			{
				break;
			}
			for (int num2 = 0; num2 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels.Count; num2++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num2].ID == Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].reel.ID && Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num2].wear == Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].reel.wear)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].reel.SetToNull();
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num2].amount++;
					return;
				}
			}
			GameManager.PlayerData.CReels cReels = new GameManager.PlayerData.CReels();
			cReels.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].reel);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels.Add(cReels);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].reel.SetToNull();
			break;
		}
		case GameManager.ItemType.Line:
		{
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].line.isNull)
			{
				break;
			}
			for (int l = 0; l < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines.Count; l++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[l].ID == Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].line.ID && Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[l].lenght == Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].line.lenght)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].line.SetToNull();
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[l].amount++;
					return;
				}
			}
			GameManager.PlayerData.CLines cLines = new GameManager.PlayerData.CLines();
			cLines.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].line);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines.Add(cLines);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].line.SetToNull();
			break;
		}
		case GameManager.ItemType.Float:
		{
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].ffloat.isNull)
			{
				break;
			}
			for (int j = 0; j < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats.Count; j++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[j].ID == Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].ffloat.ID)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].ffloat.SetToNull();
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[j].amount++;
					return;
				}
			}
			GameManager.PlayerData.CFloats cFloats = new GameManager.PlayerData.CFloats();
			cFloats.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].ffloat);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats.Add(cFloats);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].ffloat.SetToNull();
			break;
		}
		case GameManager.ItemType.Hook:
		{
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].hook.isNull)
			{
				break;
			}
			for (int k = 0; k < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks.Count; k++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[k].ID == Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].hook.ID)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].hook.SetToNull();
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[k].amount++;
					return;
				}
			}
			GameManager.PlayerData.CHooks cHooks = new GameManager.PlayerData.CHooks();
			cHooks.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].hook);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks.Add(cHooks);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].hook.SetToNull();
			break;
		}
		case GameManager.ItemType.Bait:
		{
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].bait.isNull)
			{
				break;
			}
			for (int n = 0; n < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits.Count; n++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[n].ID == Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].bait.ID)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].bait.SetToNull();
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[n].amount++;
					return;
				}
			}
			GameManager.PlayerData.CBaits cBaits = new GameManager.PlayerData.CBaits();
			cBaits.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].bait);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits.Add(cBaits);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].bait.SetToNull();
			Debug.Log("UnEquip bait " + Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].bait.isNull);
			break;
		}
		case GameManager.ItemType.Feeder:
		{
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].feeder.isNull)
			{
				break;
			}
			for (int num3 = 0; num3 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders.Count; num3++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[num3].ID == Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].feeder.ID)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].feeder.SetToNull();
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[num3].amount++;
					return;
				}
			}
			GameManager.PlayerData.CFeeders cFeeders = new GameManager.PlayerData.CFeeders();
			cFeeders.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].feeder);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders.Add(cFeeders);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].feeder.SetToNull();
			break;
		}
		case GameManager.ItemType.Leader:
		{
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].leader.isNull)
			{
				break;
			}
			for (int m = 0; m < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders.Count; m++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[m].ID == Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].leader.ID)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].leader.SetToNull();
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[m].amount++;
					return;
				}
			}
			GameManager.PlayerData.CLeaders cLeaders = new GameManager.PlayerData.CLeaders();
			cLeaders.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].leader);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders.Add(cLeaders);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].leader.SetToNull();
			break;
		}
		case GameManager.ItemType.Weight:
		{
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].weight.isNull)
			{
				break;
			}
			for (int i = 0; i < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights.Count; i++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[i].ID == Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].weight.ID)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].weight.SetToNull();
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[i].amount++;
					return;
				}
			}
			GameManager.PlayerData.CWeights cWeights = new GameManager.PlayerData.CWeights();
			cWeights.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].weight);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights.Add(cWeights);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].weight.SetToNull();
			break;
		}
		}
	}

	public void Show3D()
	{
		int num = 0;
		switch (itemType)
		{
		case GameManager.ItemType.Rod:
			num = GameManager.Instance.GetIndexByItemId(GameManager.ItemType.Rod, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].rod.ID);
			GameManager.Instance.ShowItemViewer(GameManager.Instance.gameRods[num].Get3DModelViewPrefab(), base.transform, GameManager.Instance.gameRods[num].name, GameManager.Instance.gameRods[num].GetLogoBrandImage());
			break;
		case GameManager.ItemType.Reel:
			num = GameManager.Instance.GetIndexByItemId(GameManager.ItemType.Reel, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].reel.ID);
			GameManager.Instance.ShowItemViewer(GameManager.Instance.gameReels[num].Get3DModelViewPrefab(), base.transform, GameManager.Instance.gameReels[num].name, GameManager.Instance.gameReels[num].GetLogoBrandImage());
			break;
		case GameManager.ItemType.Line:
			num = GameManager.Instance.GetIndexByItemId(GameManager.ItemType.Line, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].line.ID);
			GameManager.Instance.ShowItemViewer(GameManager.Instance.gameLines[num].Get3DModelViewPrefab(), base.transform, GameManager.Instance.gameLines[num].name, GameManager.Instance.gameLines[num].GetLogoBrandImage());
			break;
		case GameManager.ItemType.Float:
			num = GameManager.Instance.GetIndexByItemId(GameManager.ItemType.Float, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].ffloat.ID);
			GameManager.Instance.ShowItemViewer(GameManager.Instance.gameFloats[num].Get3DModelViewPrefab(), base.transform, GameManager.Instance.gameFloats[num].name, GameManager.Instance.gameFloats[num].GetLogoBrandImage());
			break;
		case GameManager.ItemType.Leader:
			num = GameManager.Instance.GetIndexByItemId(GameManager.ItemType.Leader, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].leader.ID);
			GameManager.Instance.ShowItemViewer(GameManager.Instance.gameLeaders[num].Get3DModelViewPrefab(), base.transform, GameManager.Instance.gameLeaders[num].name, GameManager.Instance.gameLeaders[num].GetLogoBrandImage());
			break;
		case GameManager.ItemType.Feeder:
			num = GameManager.Instance.GetIndexByItemId(GameManager.ItemType.Feeder, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].feeder.ID);
			GameManager.Instance.ShowItemViewer(GameManager.Instance.gameFeeders[num].Get3DModelViewPrefab(), base.transform, GameManager.Instance.gameFeeders[num].name, GameManager.Instance.gameFeeders[num].GetLogoBrandImage());
			break;
		case GameManager.ItemType.Hook:
			num = GameManager.Instance.GetIndexByItemId(GameManager.ItemType.Hook, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].hook.ID);
			GameManager.Instance.ShowItemViewer(GameManager.Instance.gameHooks[num].Get3DModelViewPrefab(), base.transform, GameManager.Instance.gameHooks[num].name, GameManager.Instance.gameHooks[num].GetLogoBrandImage());
			break;
		case GameManager.ItemType.Bait:
			num = GameManager.Instance.GetIndexByItemId(GameManager.ItemType.Bait, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].bait.ID);
			GameManager.Instance.ShowItemViewer(GameManager.Instance.gameBaits[num].Get3DModelViewPrefab(), base.transform, GameManager.Instance.gameBaits[num].name, GameManager.Instance.gameBaits[num].GetLogoBrandImage());
			break;
		case GameManager.ItemType.Weight:
			num = GameManager.Instance.GetIndexByItemId(GameManager.ItemType.Weight, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].weight.ID);
			GameManager.Instance.ShowItemViewer(GameManager.Instance.gameWeights[num].Get3DModelViewPrefab(), base.transform, GameManager.Instance.gameWeights[num].name, GameManager.Instance.gameWeights[num].GetLogoBrandImage());
			break;
		}
	}
}