1827 lines
81 KiB
C#
1827 lines
81 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEngine.UI;
|
|
|
|
public class EquipmentManager : MonoBehaviour
|
|
{
|
|
public enum ViewMode
|
|
{
|
|
Normal = 0,
|
|
Popup = 1
|
|
}
|
|
|
|
public ViewMode viewMode;
|
|
|
|
public PlayerHeader playerHeader;
|
|
|
|
public Camera mCamera;
|
|
|
|
public Image mainContentMaskImage;
|
|
|
|
public int currentSlotIndex = -1;
|
|
|
|
public Text infoSlotName;
|
|
|
|
public Transform[] slotButtons;
|
|
|
|
public Button[] resetButtons;
|
|
|
|
public Image[] damageSignSlot;
|
|
|
|
public Transform slotItemsContent;
|
|
|
|
public Transform normalItemsContent;
|
|
|
|
public Transform popupItemsContent;
|
|
|
|
public GameObject slotItemPrefab;
|
|
|
|
public GameObject slotItemInfoBarPrefab;
|
|
|
|
public Transform infoSlotContainer;
|
|
|
|
public GameObject infoItemSlotInfoPrefab;
|
|
|
|
private GameObject infoBarSlotAnim;
|
|
|
|
public Image brandLogoImage;
|
|
|
|
public bool debugMode;
|
|
|
|
[HideInInspector]
|
|
public GameManager.ItemType itemtypeToDelete;
|
|
|
|
[HideInInspector]
|
|
public int uniqueIdItemToDelete = -1;
|
|
|
|
private int lastCurrentSlotRodUniqueId = -1;
|
|
|
|
private int lastCurrentSlotRodWear = -1;
|
|
|
|
private int lastCurrentSlotReelUniqueId = -1;
|
|
|
|
private int lastCurrentSlotReelWear = -1;
|
|
|
|
private int lastCurrentSlotLineUniqueId = -1;
|
|
|
|
private int lastCurrentSlotLeaderUniqueId = -1;
|
|
|
|
private int lastCurrentSlotHookUniqueId = -1;
|
|
|
|
private int lastCurrentSlotFloatUniqueId = -1;
|
|
|
|
private int lastCurrentSlotFeederUniqueId = -1;
|
|
|
|
private int lastCurrentSlotBaitUniqueId = -1;
|
|
|
|
private int lastCurrentSlotWeightUniqueId = -1;
|
|
|
|
[Tooltip("Change Set Name PopUp")]
|
|
public GameObject setNmaePopUp;
|
|
|
|
[Tooltip("Change Set Display Transform")]
|
|
public Transform setNmaeTransform;
|
|
|
|
public Text[] CustomNamesText;
|
|
|
|
public GameManager.ItemType itemsDisplayType;
|
|
|
|
public InputField searchInputField;
|
|
|
|
public Transform popupItems;
|
|
|
|
public Dropdown sortDropdown;
|
|
|
|
private int dropdownIndex = -1;
|
|
|
|
private string sortType;
|
|
|
|
public List<Dropdown.OptionData> dropDownOptions = new List<Dropdown.OptionData>();
|
|
|
|
[HideInInspector]
|
|
public List<SlotItem> search_items = new List<SlotItem>();
|
|
|
|
private IEnumerator Start()
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] Start method is called.");
|
|
yield return null;
|
|
Debug.Log("[EquipmentManager.cs] After yield return null.");
|
|
SaveDataManager.SavePlayerDataClass currentPlayerData = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData();
|
|
if (currentPlayerData.PlayerRods == null)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] PlayerRods is null.");
|
|
}
|
|
if (currentPlayerData.PlayerReels == null)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] PlayerReels is null.");
|
|
}
|
|
if (currentPlayerData.PlayerLines == null)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] PlayerLines is null.");
|
|
}
|
|
if (currentPlayerData.PlayerLeaders == null)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] PlayerLeaders is null.");
|
|
}
|
|
if (currentPlayerData.PlayerHooks == null)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] PlayerHooks is null.");
|
|
}
|
|
if (currentPlayerData.PlayerFloats == null)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] PlayerFloats is null.");
|
|
}
|
|
if (currentPlayerData.PlayerFeeders == null)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] PlayerFeeders is null.");
|
|
}
|
|
if (currentPlayerData.PlayerBaits == null)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] PlayerBaits is null.");
|
|
}
|
|
if (currentPlayerData.PlayerWeights == null)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] PlayerWeights is null.");
|
|
}
|
|
if (currentPlayerData.PlayerSlotsEquip == null)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] PlayerSlotsEquip is null.");
|
|
}
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip == null)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] PlayerSlotsEquip is null. Initializing with PlayerSlotsEquipTemplate.");
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip = new List<GameManager.PlayerData.CSlots>(GameManager.Instance._playerData.PlayerSlotsEquipTemplate);
|
|
}
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip.Count == 0)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] PlayerSlotsEquip is empty. Initializing with PlayerSlotsEquipTemplate.");
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip = new List<GameManager.PlayerData.CSlots>(GameManager.Instance._playerData.PlayerSlotsEquipTemplate);
|
|
}
|
|
if (FScriptsHandler.Instance != null)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] FScriptsHandler.Instance is not null.");
|
|
playerHeader.gameObject.SetActive(value: true);
|
|
mainContentMaskImage.enabled = true;
|
|
if (FScriptsHandler.Instance.m_PlayerMain.currentRod != null)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] Current rod is null.");
|
|
int indexOfslot = FScriptsHandler.Instance.m_PlayerMain.currentRod.indexOfslot;
|
|
lastCurrentSlotRodUniqueId = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].rod.uniqueId;
|
|
lastCurrentSlotRodWear = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].rod.wear;
|
|
lastCurrentSlotReelUniqueId = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].reel.uniqueId;
|
|
lastCurrentSlotReelWear = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].reel.wear;
|
|
lastCurrentSlotLineUniqueId = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].line.uniqueId;
|
|
lastCurrentSlotLeaderUniqueId = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].leader.uniqueId;
|
|
lastCurrentSlotHookUniqueId = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].hook.uniqueId;
|
|
lastCurrentSlotFloatUniqueId = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].ffloat.uniqueId;
|
|
lastCurrentSlotFeederUniqueId = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].feeder.uniqueId;
|
|
lastCurrentSlotBaitUniqueId = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].bait.uniqueId;
|
|
lastCurrentSlotWeightUniqueId = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].weight.uniqueId;
|
|
slotButtons[indexOfslot].GetComponentInChildren<Text>().GetComponent<BlinkText>().enabled = true;
|
|
Debug.Log("[EquipmentManager.cs] Last equipment data retrieved from SaveDataManager.");
|
|
}
|
|
else
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] Current rod is null.");
|
|
}
|
|
FScriptsHandler.Instance.m_Canvas.gameObject.SetActive(value: false);
|
|
}
|
|
else if (Object.FindObjectOfType<Residence>() != null)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] FScriptsHandler.Instance is null. Found Residence GameObject.");
|
|
playerHeader.gameObject.SetActive(value: true);
|
|
mainContentMaskImage.enabled = true;
|
|
mCamera.transform.position = Camera.main.transform.position;
|
|
mCamera.transform.rotation = Camera.main.transform.rotation;
|
|
}
|
|
else
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] FScriptsHandler.Instance is null. No Residence found.");
|
|
playerHeader.gameObject.SetActive(value: false);
|
|
mainContentMaskImage.enabled = false;
|
|
}
|
|
if (FScriptsHandler.Instance == null)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] FScriptsHandler.Instance is null. Showing default player slot.");
|
|
ShowPlayerSlot(0);
|
|
}
|
|
else if ((bool)FScriptsHandler.Instance.m_PlayerMain.currentRod)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] Current rod is not null. Showing player slot based on current rod.");
|
|
ShowPlayerSlot(FScriptsHandler.Instance.m_PlayerMain.currentRod.indexOfslot);
|
|
}
|
|
else
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] Current rod is null. Showing default player slot.");
|
|
ShowPlayerSlot(0);
|
|
}
|
|
if (Object.FindObjectsOfType<AudioListener>().Length > 1)
|
|
{
|
|
mCamera.GetComponent<AudioListener>().enabled = false;
|
|
}
|
|
infoSlotName.text = slotButtons[currentSlotIndex].GetComponentInChildren<Text>().text;
|
|
sortDropdown.options[0].text = LanguageManager.Instance.GetText("SORT_BY_DATE");
|
|
sortDropdown.options[1].text = LanguageManager.Instance.GetText("SORT_BY_LEVEL");
|
|
sortDropdown.options[2].text = LanguageManager.Instance.GetText("SORT_BY_NAME");
|
|
}
|
|
|
|
public void ShowAccesoriesInPopup()
|
|
{
|
|
ShowHidePopupContent(visable: true, GameManager.ItemType.Accesories);
|
|
itemsDisplayType = GameManager.ItemType.Accesories;
|
|
}
|
|
|
|
public void GoToShop()
|
|
{
|
|
GameManager.Instance.LoadAddectiveScene("shop");
|
|
}
|
|
|
|
public void ShowHidePopupContent(bool visable = true, GameManager.ItemType itemtype = GameManager.ItemType.Rod, int uniqueId = -1)
|
|
{
|
|
if (visable)
|
|
{
|
|
popupItemsContent.GetComponent<EquipPopup>().uniqueId = uniqueId;
|
|
popupItemsContent.GetComponent<EquipPopup>().itemType = itemtype;
|
|
popupItemsContent.GetComponent<EquipPopup>().currentSlotindex = currentSlotIndex;
|
|
normalItemsContent.gameObject.SetActive(value: false);
|
|
popupItemsContent.gameObject.SetActive(value: true);
|
|
viewMode = ViewMode.Popup;
|
|
}
|
|
else
|
|
{
|
|
normalItemsContent.gameObject.SetActive(value: true);
|
|
popupItemsContent.gameObject.SetActive(value: false);
|
|
viewMode = ViewMode.Normal;
|
|
}
|
|
}
|
|
|
|
public void HidePopupByBtn()
|
|
{
|
|
if (viewMode == ViewMode.Normal)
|
|
{
|
|
MainGameScene mainGameScene = Object.FindObjectOfType<MainGameScene>();
|
|
if ((bool)mainGameScene)
|
|
{
|
|
mainGameScene.BackToLastContent();
|
|
}
|
|
else if (FScriptsHandler.Instance != null)
|
|
{
|
|
GameManager.Instance.LoadAddectiveScene("EscapeMenu");
|
|
}
|
|
else
|
|
{
|
|
GameManager.Instance.UnloadAddectiveScene();
|
|
}
|
|
}
|
|
normalItemsContent.gameObject.SetActive(value: true);
|
|
popupItemsContent.gameObject.SetActive(value: false);
|
|
ShowPlayerSlot(currentSlotIndex);
|
|
viewMode = ViewMode.Normal;
|
|
}
|
|
|
|
public void checkAndShowDamageSignSlot()
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] checkAndShowDamageSignSlot");
|
|
for (int i = 0; i < damageSignSlot.Length; i++)
|
|
{
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[i].CheckSlotAndRod() == 0 || Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[i].CheckSlotAndRod() == 1)
|
|
{
|
|
damageSignSlot[i].gameObject.SetActive(value: true);
|
|
}
|
|
else
|
|
{
|
|
damageSignSlot[i].gameObject.SetActive(value: false);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void SetResetButtons()
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] SetResetButtons");
|
|
for (int i = 0; i < resetButtons.Length; i++)
|
|
{
|
|
resetButtons[i].gameObject.SetActive(value: false);
|
|
}
|
|
if (currentSlotIndex > -1)
|
|
{
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].CheckSlotAndRod() == 3)
|
|
{
|
|
resetButtons[currentSlotIndex].gameObject.SetActive(value: false);
|
|
}
|
|
else
|
|
{
|
|
resetButtons[currentSlotIndex].gameObject.SetActive(value: true);
|
|
}
|
|
}
|
|
for (int j = 0; j < slotButtons.Length; j++)
|
|
{
|
|
if (j == currentSlotIndex)
|
|
{
|
|
slotButtons[j].GetComponent<Hover>().isSelected = true;
|
|
}
|
|
else
|
|
{
|
|
slotButtons[j].GetComponent<Hover>().isSelected = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void ShowRefreshItems()
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] ShowRefreshItems");
|
|
Debug.Log("[EquipmentManager.cs] ShowRefreshItems currentSlotIndex: " + currentSlotIndex);
|
|
Debug.Log("[EquipmentManager.cs] ShowRefreshItems SaveDataManager.Instance.GetCurrentPlayerData().PlayerSlotsEquip.Count: " + Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip.Count);
|
|
checkAndShowDamageSignSlot();
|
|
switch (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].CheckSlotAndRod())
|
|
{
|
|
case -1:
|
|
if (infoBarSlotAnim != null)
|
|
{
|
|
int num = slotButtons[currentSlotIndex].transform.GetSiblingIndex() + 1;
|
|
if (infoBarSlotAnim.transform.GetSiblingIndex() == num)
|
|
{
|
|
Object.Destroy(infoBarSlotAnim);
|
|
}
|
|
infoBarSlotAnim.GetComponent<Animator>().SetTrigger("Hide");
|
|
infoBarSlotAnim = null;
|
|
}
|
|
break;
|
|
case 0:
|
|
ShowInfoSlotBar(currentSlotIndex, LanguageManager.Instance.GetText("ROD_DAMAGE"));
|
|
break;
|
|
case 1:
|
|
ShowInfoSlotBar(currentSlotIndex, LanguageManager.Instance.GetText("REEL_DAMAGE"));
|
|
break;
|
|
case 2:
|
|
ShowInfoSlotBar(currentSlotIndex, LanguageManager.Instance.GetText("INCOMPLETE_SET"));
|
|
break;
|
|
case 3:
|
|
ShowInfoSlotBar(currentSlotIndex, LanguageManager.Instance.GetText("INUSE_SET"));
|
|
break;
|
|
}
|
|
GameManager.TruncateContainer(slotItemsContent);
|
|
GameManager.TruncateContainer(infoSlotContainer);
|
|
GameManager.PlayerData.CRods rod = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].rod;
|
|
GameManager.PlayerData.CReels reel = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].reel;
|
|
GameManager.PlayerData.CLines line = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].line;
|
|
GameManager.PlayerData.CHooks hook = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].hook;
|
|
GameManager.PlayerData.CFloats ffloat = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].ffloat;
|
|
GameManager.PlayerData.CBaits bait = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].bait;
|
|
GameManager.PlayerData.CFeeders feeder = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].feeder;
|
|
GameManager.PlayerData.CLeaders leader = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].leader;
|
|
GameManager.PlayerData.CWeights weight = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].weight;
|
|
if (rod.isNull)
|
|
{
|
|
CreateItemSlotSetRod(rod);
|
|
return;
|
|
}
|
|
CreateItemSlotSetRod(rod);
|
|
if (reel.isNull)
|
|
{
|
|
CreateItemSlotSetReel(reel);
|
|
return;
|
|
}
|
|
CreateItemSlotSetReel(reel);
|
|
if (line.isNull)
|
|
{
|
|
CreateItemSlotSetLine(line);
|
|
return;
|
|
}
|
|
CreateItemSlotSetLine(line);
|
|
if (leader.isNull)
|
|
{
|
|
CreateItemSlotSetLeader(leader);
|
|
}
|
|
else
|
|
{
|
|
CreateItemSlotSetLeader(leader);
|
|
}
|
|
int gameItemIndexByItemId = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Rod, rod.ID);
|
|
switch (GameManager.Instance.gameRods[gameItemIndexByItemId].type)
|
|
{
|
|
case GameManager.GameRods.Type.Universal:
|
|
if (ffloat.isNull && feeder.isNull && bait.isNull)
|
|
{
|
|
CreateItemSlotSetFloat(ffloat);
|
|
CreateItemSlotSetFeeder(feeder);
|
|
CreateItemSlotSetBait(bait, isBaitNatural: true);
|
|
}
|
|
else if (!ffloat.isNull)
|
|
{
|
|
CreateItemSlotSetFloat(ffloat);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].method = GameManager.PlayerData.CSlots.Method.Float;
|
|
}
|
|
else if (!feeder.isNull)
|
|
{
|
|
CreateItemSlotSetFeeder(feeder);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].method = GameManager.PlayerData.CSlots.Method.Feeder;
|
|
}
|
|
else if (!bait.isNull)
|
|
{
|
|
CreateItemSlotSetBait(bait);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].method = GameManager.PlayerData.CSlots.Method.Spinning;
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].status = GameManager.PlayerData.CSlots.Status.Completed;
|
|
}
|
|
break;
|
|
case GameManager.GameRods.Type.Spinning:
|
|
case GameManager.GameRods.Type.Casting:
|
|
if (bait.isNull)
|
|
{
|
|
CreateItemSlotSetBait(bait);
|
|
return;
|
|
}
|
|
CreateItemSlotSetBait(bait);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].method = GameManager.PlayerData.CSlots.Method.Spinning;
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].status = GameManager.PlayerData.CSlots.Status.Completed;
|
|
break;
|
|
case GameManager.GameRods.Type.Feeder:
|
|
if (feeder.isNull)
|
|
{
|
|
CreateItemSlotSetFeeder(feeder);
|
|
return;
|
|
}
|
|
CreateItemSlotSetFeeder(feeder);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].method = GameManager.PlayerData.CSlots.Method.Feeder;
|
|
break;
|
|
case GameManager.GameRods.Type.Float:
|
|
if (ffloat.isNull)
|
|
{
|
|
CreateItemSlotSetFloat(ffloat);
|
|
return;
|
|
}
|
|
CreateItemSlotSetFloat(ffloat);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].method = GameManager.PlayerData.CSlots.Method.Float;
|
|
break;
|
|
}
|
|
switch (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].method)
|
|
{
|
|
case GameManager.PlayerData.CSlots.Method.Float:
|
|
if (weight.isNull)
|
|
{
|
|
CreateItemSlotSetWeight(weight);
|
|
break;
|
|
}
|
|
CreateItemSlotSetWeight(weight);
|
|
if (hook.isNull)
|
|
{
|
|
CreateItemSlotSetHook(hook);
|
|
break;
|
|
}
|
|
CreateItemSlotSetHook(hook);
|
|
if (bait.isNull)
|
|
{
|
|
CreateItemSlotSetBait(bait, isBaitNatural: true);
|
|
break;
|
|
}
|
|
CreateItemSlotSetBait(bait, isBaitNatural: true);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].status = GameManager.PlayerData.CSlots.Status.Completed;
|
|
break;
|
|
case GameManager.PlayerData.CSlots.Method.Feeder:
|
|
if (hook.isNull)
|
|
{
|
|
CreateItemSlotSetHook(hook);
|
|
break;
|
|
}
|
|
CreateItemSlotSetHook(hook);
|
|
if (bait.isNull)
|
|
{
|
|
CreateItemSlotSetBait(bait, isBaitNatural: true);
|
|
break;
|
|
}
|
|
CreateItemSlotSetBait(bait, isBaitNatural: true);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].status = GameManager.PlayerData.CSlots.Status.Completed;
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void CreateItemSlotSetBait(GameManager.PlayerData.CBaits bait, bool isBaitNatural = false)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] CreateItemSlotSetBait isBaitNatural: " + isBaitNatural);
|
|
SlotItem component = Object.Instantiate(slotItemPrefab, slotItemsContent).GetComponent<SlotItem>();
|
|
component.currentSlotIndex = currentSlotIndex;
|
|
component.bait = bait;
|
|
component.isBaitNatural = isBaitNatural;
|
|
component.itemType = GameManager.ItemType.Bait;
|
|
component.deleteItemButton.gameObject.SetActive(value: false);
|
|
component.SetupItem();
|
|
}
|
|
|
|
private void CreateItemSlotSetRod(GameManager.PlayerData.CRods rod)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] CreateItemSlotSetRod");
|
|
SlotItem component = Object.Instantiate(slotItemPrefab, slotItemsContent).GetComponent<SlotItem>();
|
|
component.currentSlotIndex = currentSlotIndex;
|
|
component.rod = rod;
|
|
component.itemType = GameManager.ItemType.Rod;
|
|
component.deleteItemButton.gameObject.SetActive(value: false);
|
|
component.SetupItem();
|
|
}
|
|
|
|
private void CreateItemSlotSetReel(GameManager.PlayerData.CReels reel)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] CreateItemSlotSetReel");
|
|
SlotItem component = Object.Instantiate(slotItemPrefab, slotItemsContent).GetComponent<SlotItem>();
|
|
component.currentSlotIndex = currentSlotIndex;
|
|
component.reel = reel;
|
|
component.itemType = GameManager.ItemType.Reel;
|
|
component.deleteItemButton.gameObject.SetActive(value: false);
|
|
component.SetupItem();
|
|
}
|
|
|
|
private void CreateItemSlotSetLine(GameManager.PlayerData.CLines line)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] CreateItemSlotSetLine");
|
|
SlotItem component = Object.Instantiate(slotItemPrefab, slotItemsContent).GetComponent<SlotItem>();
|
|
component.currentSlotIndex = currentSlotIndex;
|
|
component.line = line;
|
|
component.itemType = GameManager.ItemType.Line;
|
|
component.deleteItemButton.gameObject.SetActive(value: false);
|
|
component.SetupItem();
|
|
}
|
|
|
|
private void CreateItemSlotSetLeader(GameManager.PlayerData.CLeaders leader)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] CreateItemSlotSetLeader");
|
|
SlotItem component = Object.Instantiate(slotItemPrefab, slotItemsContent).GetComponent<SlotItem>();
|
|
component.currentSlotIndex = currentSlotIndex;
|
|
component.leader = leader;
|
|
component.itemType = GameManager.ItemType.Leader;
|
|
component.deleteItemButton.gameObject.SetActive(value: false);
|
|
component.SetupItem();
|
|
}
|
|
|
|
private void CreateItemSlotSetFloat(GameManager.PlayerData.CFloats ffloat)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] CreateItemSlotSetFloat");
|
|
SlotItem component = Object.Instantiate(slotItemPrefab, slotItemsContent).GetComponent<SlotItem>();
|
|
component.currentSlotIndex = currentSlotIndex;
|
|
component.ffloat = ffloat;
|
|
component.itemType = GameManager.ItemType.Float;
|
|
component.deleteItemButton.gameObject.SetActive(value: false);
|
|
component.SetupItem();
|
|
}
|
|
|
|
private void CreateItemSlotSetHook(GameManager.PlayerData.CHooks hook)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] CreateItemSlotSetHook");
|
|
SlotItem component = Object.Instantiate(slotItemPrefab, slotItemsContent).GetComponent<SlotItem>();
|
|
component.currentSlotIndex = currentSlotIndex;
|
|
component.hook = hook;
|
|
component.itemType = GameManager.ItemType.Hook;
|
|
component.deleteItemButton.gameObject.SetActive(value: false);
|
|
component.SetupItem();
|
|
}
|
|
|
|
private void CreateItemSlotSetFeeder(GameManager.PlayerData.CFeeders feeder)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] CreateItemSlotSetFeeder");
|
|
SlotItem component = Object.Instantiate(slotItemPrefab, slotItemsContent).GetComponent<SlotItem>();
|
|
component.currentSlotIndex = currentSlotIndex;
|
|
component.feeder = feeder;
|
|
component.itemType = GameManager.ItemType.Feeder;
|
|
component.deleteItemButton.gameObject.SetActive(value: false);
|
|
component.SetupItem();
|
|
}
|
|
|
|
private void CreateItemSlotSetWeight(GameManager.PlayerData.CWeights weight)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] CreateItemSlotSetWeight");
|
|
SlotItem component = Object.Instantiate(slotItemPrefab, slotItemsContent).GetComponent<SlotItem>();
|
|
component.currentSlotIndex = currentSlotIndex;
|
|
component.weight = weight;
|
|
component.itemType = GameManager.ItemType.Weight;
|
|
component.deleteItemButton.gameObject.SetActive(value: false);
|
|
component.SetupItem();
|
|
}
|
|
|
|
public void CreateItemsStatsEquiped(GameManager.ItemType itemType, int index)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] CreateItemsStatsEquiped index: " + index);
|
|
if (index != -1)
|
|
{
|
|
StatItemEquiped component = Object.Instantiate(infoItemSlotInfoPrefab, infoSlotContainer).GetComponent<StatItemEquiped>();
|
|
component.equipmentManager = this;
|
|
component.Setup(itemType, index);
|
|
}
|
|
}
|
|
|
|
public void ShowPlayerSlot(int index)
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] ShowPlayerSlot[" + index + "]");
|
|
Debug.Log("[EquipmentManager.cs] SaveDataManager.Instance.GetCurrentPlayerData().PlayerSlotsEquip.Count: " + Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip.Count);
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip.Count > index)
|
|
{
|
|
currentSlotIndex = index;
|
|
infoSlotName.text = slotButtons[currentSlotIndex].GetComponentInChildren<Text>().text;
|
|
SetResetButtons();
|
|
ShowRefreshItems();
|
|
}
|
|
}
|
|
|
|
public void ResetAllSlotByButton()
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] ResetAllSlotByButton");
|
|
GameManager.Instance.CreateMessageBox("RESET_SLOT_QUESTION", GetComponent<Canvas>().transform, 1);
|
|
}
|
|
|
|
public void ResetAllSlot()
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] ResetAllSlot");
|
|
UnEquipAll();
|
|
ShowRefreshItems();
|
|
if (infoBarSlotAnim != null)
|
|
{
|
|
Object.Destroy(infoBarSlotAnim.gameObject);
|
|
}
|
|
}
|
|
|
|
public void UnEquipAll()
|
|
{
|
|
Debug.Log("[EquipmentManager.cs] UnEquipAll currentSlotIndex: " + currentSlotIndex);
|
|
GameManager.PlayerData.CRods rod = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].rod;
|
|
GameManager.PlayerData.CReels reel = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].reel;
|
|
GameManager.PlayerData.CLines line = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].line;
|
|
GameManager.PlayerData.CHooks hook = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].hook;
|
|
GameManager.PlayerData.CFloats ffloat = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].ffloat;
|
|
GameManager.PlayerData.CBaits bait = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].bait;
|
|
GameManager.PlayerData.CFeeders feeder = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].feeder;
|
|
GameManager.PlayerData.CLeaders leader = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].leader;
|
|
GameManager.PlayerData.CWeights weight = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].weight;
|
|
bool flag = false;
|
|
if (!rod.isNull)
|
|
{
|
|
flag = false;
|
|
for (int i = 0; i < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods.Count; i++)
|
|
{
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[i].ID == rod.ID && Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[i].wear == rod.wear)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[i].amount++;
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[i].status = GameManager.PlayerData.CRods.Status.InEquip;
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].rod.SetToNull();
|
|
flag = true;
|
|
}
|
|
}
|
|
if (!flag)
|
|
{
|
|
GameManager.PlayerData.CRods cRods = new GameManager.PlayerData.CRods();
|
|
cRods.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].rod);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].rod.SetToNull();
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods.Add(cRods);
|
|
}
|
|
}
|
|
if (!reel.isNull)
|
|
{
|
|
flag = false;
|
|
for (int j = 0; j < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels.Count; j++)
|
|
{
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[j].ID == reel.ID && Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[j].wear == reel.wear)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[j].amount++;
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].reel.SetToNull();
|
|
flag = true;
|
|
}
|
|
}
|
|
if (!flag)
|
|
{
|
|
GameManager.PlayerData.CReels cReels = new GameManager.PlayerData.CReels();
|
|
cReels.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].reel);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].reel.SetToNull();
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels.Add(cReels);
|
|
}
|
|
}
|
|
if (!line.isNull)
|
|
{
|
|
flag = false;
|
|
for (int k = 0; k < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines.Count; k++)
|
|
{
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[k].ID == line.ID && Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[k].lenght == line.lenght)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[k].amount++;
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].line.SetToNull();
|
|
flag = true;
|
|
}
|
|
}
|
|
if (!flag)
|
|
{
|
|
GameManager.PlayerData.CLines cLines = new GameManager.PlayerData.CLines();
|
|
cLines.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].line);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].line.SetToNull();
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines.Add(cLines);
|
|
}
|
|
}
|
|
if (!ffloat.isNull)
|
|
{
|
|
flag = false;
|
|
for (int l = 0; l < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats.Count; l++)
|
|
{
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[l].ID == ffloat.ID)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[l].amount++;
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].ffloat.SetToNull();
|
|
flag = true;
|
|
}
|
|
}
|
|
if (!flag)
|
|
{
|
|
GameManager.PlayerData.CFloats cFloats = new GameManager.PlayerData.CFloats();
|
|
cFloats.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].ffloat);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].ffloat.SetToNull();
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats.Add(cFloats);
|
|
}
|
|
}
|
|
if (!hook.isNull)
|
|
{
|
|
flag = false;
|
|
for (int m = 0; m < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks.Count; m++)
|
|
{
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[m].ID == hook.ID)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[m].amount++;
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].hook.SetToNull();
|
|
flag = true;
|
|
}
|
|
}
|
|
if (!flag)
|
|
{
|
|
GameManager.PlayerData.CHooks cHooks = new GameManager.PlayerData.CHooks();
|
|
cHooks.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].hook);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].hook.SetToNull();
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks.Add(cHooks);
|
|
}
|
|
}
|
|
if (!bait.isNull)
|
|
{
|
|
flag = false;
|
|
for (int n = 0; n < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits.Count; n++)
|
|
{
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[n].ID == bait.ID)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[n].amount++;
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].bait.SetToNull();
|
|
flag = true;
|
|
}
|
|
}
|
|
if (!flag)
|
|
{
|
|
GameManager.PlayerData.CBaits cBaits = new GameManager.PlayerData.CBaits();
|
|
cBaits.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].bait);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].bait.SetToNull();
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits.Add(cBaits);
|
|
}
|
|
}
|
|
if (!feeder.isNull)
|
|
{
|
|
flag = false;
|
|
for (int num = 0; num < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders.Count; num++)
|
|
{
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[num].ID == feeder.ID)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[num].amount++;
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].feeder.SetToNull();
|
|
flag = true;
|
|
}
|
|
}
|
|
if (!flag)
|
|
{
|
|
GameManager.PlayerData.CFeeders cFeeders = new GameManager.PlayerData.CFeeders();
|
|
cFeeders.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].feeder);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].feeder.SetToNull();
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders.Add(cFeeders);
|
|
}
|
|
}
|
|
if (!leader.isNull)
|
|
{
|
|
flag = false;
|
|
for (int num2 = 0; num2 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders.Count; num2++)
|
|
{
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[num2].ID == leader.ID)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[num2].amount++;
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].leader.SetToNull();
|
|
flag = true;
|
|
}
|
|
}
|
|
if (!flag)
|
|
{
|
|
GameManager.PlayerData.CLeaders cLeaders = new GameManager.PlayerData.CLeaders();
|
|
cLeaders.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].leader);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].leader.SetToNull();
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders.Add(cLeaders);
|
|
}
|
|
}
|
|
if (!weight.isNull)
|
|
{
|
|
flag = false;
|
|
for (int num3 = 0; num3 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights.Count; num3++)
|
|
{
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[num3].ID == weight.ID)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[num3].amount++;
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].weight.SetToNull();
|
|
flag = true;
|
|
}
|
|
}
|
|
if (!flag)
|
|
{
|
|
GameManager.PlayerData.CWeights cWeights = new GameManager.PlayerData.CWeights();
|
|
cWeights.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].weight);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].weight.SetToNull();
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights.Add(cWeights);
|
|
}
|
|
}
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].status = GameManager.PlayerData.CSlots.Status.Empty;
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].method = GameManager.PlayerData.CSlots.Method.None;
|
|
}
|
|
|
|
private bool CheckChangecInCurrentRodSlot()
|
|
{
|
|
if (FScriptsHandler.Instance == null)
|
|
{
|
|
return false;
|
|
}
|
|
if (!FScriptsHandler.Instance.m_PlayerMain.currentRod)
|
|
{
|
|
return false;
|
|
}
|
|
int indexOfslot = FScriptsHandler.Instance.m_PlayerMain.currentRod.indexOfslot;
|
|
if (indexOfslot != -1)
|
|
{
|
|
if (lastCurrentSlotRodUniqueId != Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].rod.uniqueId)
|
|
{
|
|
return true;
|
|
}
|
|
if (lastCurrentSlotRodWear != Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].rod.wear)
|
|
{
|
|
return true;
|
|
}
|
|
if (lastCurrentSlotReelUniqueId != Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].reel.uniqueId)
|
|
{
|
|
return true;
|
|
}
|
|
if (lastCurrentSlotReelWear != Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].reel.wear)
|
|
{
|
|
return true;
|
|
}
|
|
if (lastCurrentSlotLineUniqueId != Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].line.uniqueId)
|
|
{
|
|
return true;
|
|
}
|
|
if (lastCurrentSlotLeaderUniqueId != Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].leader.uniqueId)
|
|
{
|
|
return true;
|
|
}
|
|
if (lastCurrentSlotHookUniqueId != Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].hook.uniqueId)
|
|
{
|
|
return true;
|
|
}
|
|
if (lastCurrentSlotFloatUniqueId != Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].ffloat.uniqueId)
|
|
{
|
|
return true;
|
|
}
|
|
if (lastCurrentSlotFeederUniqueId != Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].feeder.uniqueId)
|
|
{
|
|
return true;
|
|
}
|
|
if (lastCurrentSlotBaitUniqueId != Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].bait.uniqueId)
|
|
{
|
|
return true;
|
|
}
|
|
if (lastCurrentSlotWeightUniqueId != Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].weight.uniqueId)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void ShowInfoSlotBar(int indexOfSlot, string textOfInfo)
|
|
{
|
|
int num = slotButtons[indexOfSlot].transform.GetSiblingIndex() + 1;
|
|
if (infoBarSlotAnim != null)
|
|
{
|
|
if (infoBarSlotAnim.transform.GetSiblingIndex() == num)
|
|
{
|
|
return;
|
|
}
|
|
infoBarSlotAnim.GetComponent<Animator>().SetTrigger("Hide");
|
|
infoBarSlotAnim = null;
|
|
}
|
|
infoBarSlotAnim = Object.Instantiate(slotItemInfoBarPrefab, slotButtons[indexOfSlot].transform.parent);
|
|
infoBarSlotAnim.transform.SetSiblingIndex(num);
|
|
infoBarSlotAnim.GetComponent<SlotInfoBarScript>().infoBarText.text = textOfInfo;
|
|
}
|
|
|
|
public void DeleteItemConfirmYes()
|
|
{
|
|
if (uniqueIdItemToDelete == -1)
|
|
{
|
|
return;
|
|
}
|
|
int playerItemIndexByUniqueId = GameManager.Instance._playerData.GetPlayerItemIndexByUniqueId(itemtypeToDelete, uniqueIdItemToDelete);
|
|
int num = 1;
|
|
int id = 0;
|
|
bool flag = false;
|
|
switch (itemtypeToDelete)
|
|
{
|
|
case GameManager.ItemType.Rod:
|
|
num = GameManager.Instance.GetGameItemAmount(itemtypeToDelete, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[playerItemIndexByUniqueId].ID);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[playerItemIndexByUniqueId].amount -= num;
|
|
id = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[playerItemIndexByUniqueId].ID;
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[playerItemIndexByUniqueId].amount <= 0)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods.RemoveAt(playerItemIndexByUniqueId);
|
|
flag = true;
|
|
}
|
|
break;
|
|
case GameManager.ItemType.Reel:
|
|
num = GameManager.Instance.GetGameItemAmount(itemtypeToDelete, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[playerItemIndexByUniqueId].ID);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[playerItemIndexByUniqueId].amount -= num;
|
|
id = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[playerItemIndexByUniqueId].ID;
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[playerItemIndexByUniqueId].amount <= 0)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels.RemoveAt(playerItemIndexByUniqueId);
|
|
flag = true;
|
|
}
|
|
break;
|
|
case GameManager.ItemType.Line:
|
|
num = GameManager.Instance.GetGameItemAmount(itemtypeToDelete, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[playerItemIndexByUniqueId].ID);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[playerItemIndexByUniqueId].amount -= num;
|
|
id = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[playerItemIndexByUniqueId].ID;
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[playerItemIndexByUniqueId].amount <= 0)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines.RemoveAt(playerItemIndexByUniqueId);
|
|
flag = true;
|
|
}
|
|
break;
|
|
case GameManager.ItemType.Leader:
|
|
num = GameManager.Instance.GetGameItemAmount(itemtypeToDelete, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[playerItemIndexByUniqueId].ID);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[playerItemIndexByUniqueId].amount -= num;
|
|
id = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[playerItemIndexByUniqueId].ID;
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[playerItemIndexByUniqueId].amount <= 0)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders.RemoveAt(playerItemIndexByUniqueId);
|
|
flag = true;
|
|
}
|
|
break;
|
|
case GameManager.ItemType.Float:
|
|
num = GameManager.Instance.GetGameItemAmount(itemtypeToDelete, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[playerItemIndexByUniqueId].ID);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[playerItemIndexByUniqueId].amount -= num;
|
|
id = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[playerItemIndexByUniqueId].ID;
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[playerItemIndexByUniqueId].amount <= 0)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats.RemoveAt(playerItemIndexByUniqueId);
|
|
flag = true;
|
|
}
|
|
break;
|
|
case GameManager.ItemType.Feeder:
|
|
num = GameManager.Instance.GetGameItemAmount(itemtypeToDelete, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[playerItemIndexByUniqueId].ID);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[playerItemIndexByUniqueId].amount -= num;
|
|
id = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[playerItemIndexByUniqueId].ID;
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[playerItemIndexByUniqueId].amount <= 0)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders.RemoveAt(playerItemIndexByUniqueId);
|
|
flag = true;
|
|
}
|
|
break;
|
|
case GameManager.ItemType.Groundbaits:
|
|
num = GameManager.Instance.GetGameItemAmount(itemtypeToDelete, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerGroundbaits[playerItemIndexByUniqueId].ID);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerGroundbaits[playerItemIndexByUniqueId].amount -= num;
|
|
id = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerGroundbaits[playerItemIndexByUniqueId].ID;
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerGroundbaits[playerItemIndexByUniqueId].amount <= 0)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerGroundbaits.RemoveAt(playerItemIndexByUniqueId);
|
|
flag = true;
|
|
}
|
|
break;
|
|
case GameManager.ItemType.Hook:
|
|
num = GameManager.Instance.GetGameItemAmount(itemtypeToDelete, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[playerItemIndexByUniqueId].ID);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[playerItemIndexByUniqueId].amount -= num;
|
|
id = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[playerItemIndexByUniqueId].ID;
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[playerItemIndexByUniqueId].amount <= 0)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks.RemoveAt(playerItemIndexByUniqueId);
|
|
flag = true;
|
|
}
|
|
break;
|
|
case GameManager.ItemType.Weight:
|
|
num = GameManager.Instance.GetGameItemAmount(itemtypeToDelete, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[playerItemIndexByUniqueId].ID);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[playerItemIndexByUniqueId].amount -= num;
|
|
id = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[playerItemIndexByUniqueId].ID;
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[playerItemIndexByUniqueId].amount <= 0)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights.RemoveAt(playerItemIndexByUniqueId);
|
|
flag = true;
|
|
}
|
|
break;
|
|
case GameManager.ItemType.Accesories:
|
|
num = GameManager.Instance.GetGameItemAmount(itemtypeToDelete, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[playerItemIndexByUniqueId].ID);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[playerItemIndexByUniqueId].amount -= num;
|
|
id = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[playerItemIndexByUniqueId].ID;
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[playerItemIndexByUniqueId].amount <= 0)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories.RemoveAt(playerItemIndexByUniqueId);
|
|
flag = true;
|
|
}
|
|
break;
|
|
case GameManager.ItemType.Bait:
|
|
num = GameManager.Instance.GetGameItemAmount(itemtypeToDelete, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[playerItemIndexByUniqueId].ID);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[playerItemIndexByUniqueId].amount -= num;
|
|
id = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[playerItemIndexByUniqueId].ID;
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[playerItemIndexByUniqueId].amount <= 0)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits.RemoveAt(playerItemIndexByUniqueId);
|
|
flag = true;
|
|
}
|
|
break;
|
|
}
|
|
SlotItem[] componentsInChildren = popupItemsContent.GetComponentsInChildren<SlotItem>();
|
|
for (int i = 0; i < componentsInChildren.Length; i++)
|
|
{
|
|
if (componentsInChildren[i].itemType == itemtypeToDelete && componentsInChildren[i].itemUniqueId == uniqueIdItemToDelete)
|
|
{
|
|
if (flag)
|
|
{
|
|
Object.Destroy(componentsInChildren[i].gameObject);
|
|
Object.FindObjectOfType<EquipPopup>().RefreshSort();
|
|
}
|
|
else
|
|
{
|
|
componentsInChildren[i].Setup(itemtypeToDelete, id, uniqueIdItemToDelete);
|
|
}
|
|
}
|
|
}
|
|
uniqueIdItemToDelete = -1;
|
|
}
|
|
|
|
private void OnDestroy()
|
|
{
|
|
if (FScriptsHandler.Instance != null)
|
|
{
|
|
Debug.Log("Close equipment: " + CheckChangecInCurrentRodSlot());
|
|
if (CheckChangecInCurrentRodSlot())
|
|
{
|
|
FScriptsHandler.Instance.m_InventoryManager.reAssignRod = true;
|
|
}
|
|
FScriptsHandler.Instance.m_Canvas.gameObject.SetActive(value: true);
|
|
}
|
|
}
|
|
|
|
public void ChangeSetName(int id)
|
|
{
|
|
SetNamePopUpItem component = Object.Instantiate(setNmaePopUp, setNmaeTransform).GetComponent<SetNamePopUpItem>();
|
|
component.SetID = id;
|
|
component.customNameText = CustomNamesText[id - 1];
|
|
}
|
|
|
|
public void searchRealtime()
|
|
{
|
|
GameManager.TruncateContainer(popupItems);
|
|
switch (itemsDisplayType)
|
|
{
|
|
case GameManager.ItemType.Bait:
|
|
{
|
|
if (searchInputField.text.Length < 2)
|
|
{
|
|
List<GameManager.PlayerData.CBaits> list13 = new List<GameManager.PlayerData.CBaits>();
|
|
for (int num19 = 0; num19 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits.Count; num19++)
|
|
{
|
|
if (!list13.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[num19]))
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[num19].amount = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[num19].amount;
|
|
list13.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[num19]);
|
|
}
|
|
}
|
|
for (int num20 = 0; num20 < list13.Count; num20++)
|
|
{
|
|
SlotItem component13 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
|
|
component13.currentSlotIndex = currentSlotIndex;
|
|
component13.bait = list13[num20];
|
|
component13.bait.amount = list13[num20].amount;
|
|
component13.isBaitNatural = false;
|
|
component13.itemType = GameManager.ItemType.Bait;
|
|
component13.deleteItemButton.gameObject.SetActive(value: true);
|
|
if (component13.bait.amount > 1)
|
|
{
|
|
Text itemStatText5 = component13.itemStatText;
|
|
itemStatText5.text = itemStatText5.text + "\nx " + list13[num20].amount;
|
|
}
|
|
component13.SetupItem();
|
|
}
|
|
break;
|
|
}
|
|
List<GameManager.PlayerData.CBaits> list14 = new List<GameManager.PlayerData.CBaits>();
|
|
for (int num21 = 0; num21 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits.Count; num21++)
|
|
{
|
|
if (!list14.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[num21]))
|
|
{
|
|
list14.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[num21]);
|
|
}
|
|
}
|
|
for (int num22 = 0; num22 < list14.Count; num22++)
|
|
{
|
|
if (GameManager.Instance.GetGameItemName(GameManager.ItemType.Bait, list14[num22].ID).ToUpper().Contains(searchInputField.text.ToUpper()))
|
|
{
|
|
SlotItem component14 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
|
|
component14.currentSlotIndex = currentSlotIndex;
|
|
component14.bait = list14[num22];
|
|
component14.bait.amount = list14[num22].amount;
|
|
component14.isBaitNatural = false;
|
|
component14.itemType = GameManager.ItemType.Bait;
|
|
component14.deleteItemButton.gameObject.SetActive(value: true);
|
|
if (component14.bait.amount > 1)
|
|
{
|
|
Text itemStatText6 = component14.itemStatText;
|
|
itemStatText6.text = itemStatText6.text + "\nx " + list14[num22].amount;
|
|
}
|
|
component14.SetupItem();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case GameManager.ItemType.Reel:
|
|
{
|
|
if (searchInputField.text.Length < 2)
|
|
{
|
|
List<GameManager.PlayerData.CReels> list11 = new List<GameManager.PlayerData.CReels>();
|
|
for (int num15 = 0; num15 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels.Count; num15++)
|
|
{
|
|
if (!list11.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num15]))
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num15].amount = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num15].amount;
|
|
list11.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num15]);
|
|
}
|
|
}
|
|
for (int num16 = 0; num16 < list11.Count; num16++)
|
|
{
|
|
SlotItem component11 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
|
|
component11.currentSlotIndex = currentSlotIndex;
|
|
component11.reel = list11[num16];
|
|
component11.reel.amount = list11[num16].amount;
|
|
component11.isBaitNatural = false;
|
|
component11.itemType = GameManager.ItemType.Reel;
|
|
component11.deleteItemButton.gameObject.SetActive(value: true);
|
|
if (component11.reel.amount > 1)
|
|
{
|
|
Text itemStatText3 = component11.itemStatText;
|
|
itemStatText3.text = itemStatText3.text + "\nx " + list11[num16].amount;
|
|
}
|
|
component11.SetupItem();
|
|
}
|
|
break;
|
|
}
|
|
List<GameManager.PlayerData.CReels> list12 = new List<GameManager.PlayerData.CReels>();
|
|
for (int num17 = 0; num17 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels.Count; num17++)
|
|
{
|
|
if (!list12.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num17]))
|
|
{
|
|
list12.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num17]);
|
|
}
|
|
}
|
|
for (int num18 = 0; num18 < list12.Count; num18++)
|
|
{
|
|
if (GameManager.Instance.GetGameItemName(GameManager.ItemType.Reel, list12[num18].ID).ToUpper().Contains(searchInputField.text.ToUpper()))
|
|
{
|
|
SlotItem component12 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
|
|
component12.currentSlotIndex = currentSlotIndex;
|
|
component12.reel = list12[num18];
|
|
component12.reel.amount = list12[num18].amount;
|
|
component12.isBaitNatural = false;
|
|
component12.itemType = GameManager.ItemType.Reel;
|
|
component12.deleteItemButton.gameObject.SetActive(value: true);
|
|
if (component12.reel.amount > 1)
|
|
{
|
|
Text itemStatText4 = component12.itemStatText;
|
|
itemStatText4.text = itemStatText4.text + "\nx " + list12[num18].amount;
|
|
}
|
|
component12.SetupItem();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case GameManager.ItemType.Weight:
|
|
{
|
|
if (searchInputField.text.Length < 2)
|
|
{
|
|
List<GameManager.PlayerData.CWeights> list17 = new List<GameManager.PlayerData.CWeights>();
|
|
for (int num27 = 0; num27 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights.Count; num27++)
|
|
{
|
|
if (!list17.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[num27]))
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[num27].amount = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[num27].amount;
|
|
list17.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[num27]);
|
|
}
|
|
}
|
|
for (int num28 = 0; num28 < list17.Count; num28++)
|
|
{
|
|
SlotItem component17 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
|
|
component17.currentSlotIndex = currentSlotIndex;
|
|
component17.weight = list17[num28];
|
|
component17.weight.amount = list17[num28].amount;
|
|
component17.isBaitNatural = false;
|
|
component17.itemType = GameManager.ItemType.Weight;
|
|
component17.deleteItemButton.gameObject.SetActive(value: true);
|
|
component17.SetupItem();
|
|
int gameItemIndexByItemId9 = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Weight, list17[num28].ID);
|
|
if (component17.weight.amount > 1)
|
|
{
|
|
component17.itemStatText.text = GameManager.Instance.gameWeights[gameItemIndexByItemId9].weight.ToString("F0") + "g\nx " + list17[num28].amount;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
List<GameManager.PlayerData.CWeights> list18 = new List<GameManager.PlayerData.CWeights>();
|
|
for (int num29 = 0; num29 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights.Count; num29++)
|
|
{
|
|
if (!list18.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[num29]))
|
|
{
|
|
list18.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[num29]);
|
|
}
|
|
}
|
|
for (int num30 = 0; num30 < list18.Count; num30++)
|
|
{
|
|
if (GameManager.Instance.GetGameItemName(GameManager.ItemType.Weight, list18[num30].ID).ToUpper().Contains(searchInputField.text.ToUpper()))
|
|
{
|
|
SlotItem component18 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
|
|
component18.currentSlotIndex = currentSlotIndex;
|
|
component18.weight = list18[num30];
|
|
component18.weight.amount = list18[num30].amount;
|
|
component18.isBaitNatural = false;
|
|
component18.itemType = GameManager.ItemType.Weight;
|
|
component18.deleteItemButton.gameObject.SetActive(value: true);
|
|
component18.SetupItem();
|
|
int gameItemIndexByItemId10 = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Weight, list18[num30].ID);
|
|
if (component18.weight.amount > 1)
|
|
{
|
|
component18.itemStatText.text = GameManager.Instance.gameWeights[gameItemIndexByItemId10].weight.ToString("F0") + "g\nx " + list18[num30].amount;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case GameManager.ItemType.Leader:
|
|
{
|
|
if (searchInputField.text.Length < 2)
|
|
{
|
|
List<GameManager.PlayerData.CLeaders> list9 = new List<GameManager.PlayerData.CLeaders>();
|
|
for (int num11 = 0; num11 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders.Count; num11++)
|
|
{
|
|
if (!list9.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[num11]))
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[num11].amount = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[num11].amount;
|
|
list9.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[num11]);
|
|
}
|
|
}
|
|
for (int num12 = 0; num12 < list9.Count; num12++)
|
|
{
|
|
SlotItem component9 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
|
|
component9.currentSlotIndex = currentSlotIndex;
|
|
component9.leader = list9[num12];
|
|
component9.leader.amount = list9[num12].amount;
|
|
component9.isBaitNatural = false;
|
|
component9.itemType = GameManager.ItemType.Leader;
|
|
component9.deleteItemButton.gameObject.SetActive(value: true);
|
|
if (component9.reel.amount > 1)
|
|
{
|
|
Text itemStatText = component9.itemStatText;
|
|
itemStatText.text = itemStatText.text + "\nx " + list9[num12].amount;
|
|
}
|
|
component9.SetupItem();
|
|
}
|
|
break;
|
|
}
|
|
List<GameManager.PlayerData.CLeaders> list10 = new List<GameManager.PlayerData.CLeaders>();
|
|
for (int num13 = 0; num13 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders.Count; num13++)
|
|
{
|
|
if (!list10.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[num13]))
|
|
{
|
|
list10.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[num13]);
|
|
}
|
|
}
|
|
for (int num14 = 0; num14 < list10.Count; num14++)
|
|
{
|
|
if (GameManager.Instance.GetGameItemName(GameManager.ItemType.Leader, list10[num14].ID).ToUpper().Contains(searchInputField.text.ToUpper()))
|
|
{
|
|
SlotItem component10 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
|
|
component10.currentSlotIndex = currentSlotIndex;
|
|
component10.leader = list10[num14];
|
|
component10.leader.amount = list10[num14].amount;
|
|
component10.isBaitNatural = false;
|
|
component10.itemType = GameManager.ItemType.Leader;
|
|
component10.deleteItemButton.gameObject.SetActive(value: true);
|
|
if (component10.reel.amount > 1)
|
|
{
|
|
Text itemStatText2 = component10.itemStatText;
|
|
itemStatText2.text = itemStatText2.text + "\nx " + list10[num14].amount;
|
|
}
|
|
component10.SetupItem();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case GameManager.ItemType.Line:
|
|
{
|
|
if (searchInputField.text.Length < 2)
|
|
{
|
|
List<GameManager.PlayerData.CLines> list19 = new List<GameManager.PlayerData.CLines>();
|
|
for (int num31 = 0; num31 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines.Count; num31++)
|
|
{
|
|
if (!list19.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[num31]))
|
|
{
|
|
GameManager.PlayerData.CLines cLines = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[num31];
|
|
cLines.amount = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[num31].amount;
|
|
cLines.lenght = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[num31].lenght;
|
|
list19.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[num31]);
|
|
}
|
|
}
|
|
for (int num32 = 0; num32 < list19.Count; num32++)
|
|
{
|
|
SlotItem component19 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
|
|
component19.currentSlotIndex = currentSlotIndex;
|
|
component19.line = list19[num32];
|
|
component19.line.amount = list19[num32].amount;
|
|
component19.line.lenght = list19[num32].lenght;
|
|
component19.isBaitNatural = false;
|
|
component19.itemType = GameManager.ItemType.Line;
|
|
component19.deleteItemButton.gameObject.SetActive(value: true);
|
|
component19.SetupItem();
|
|
int gameItemIndexByItemId11 = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Line, list19[num32].ID);
|
|
component19.itemStatText.text = GameManager.Instance.ConvertWeight(GameManager.Instance.gameLines[gameItemIndexByItemId11].strength);
|
|
Text itemStatText7 = component19.itemStatText;
|
|
itemStatText7.text = itemStatText7.text + "\n" + GameManager.Instance.ConvertLenghtWithUnit(list19[num32].lenght, "F0");
|
|
}
|
|
break;
|
|
}
|
|
List<GameManager.PlayerData.CLines> list20 = new List<GameManager.PlayerData.CLines>();
|
|
for (int num33 = 0; num33 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines.Count; num33++)
|
|
{
|
|
if (!list20.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[num33]))
|
|
{
|
|
list20.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[num33]);
|
|
}
|
|
}
|
|
for (int num34 = 0; num34 < list20.Count; num34++)
|
|
{
|
|
if (GameManager.Instance.GetGameItemName(GameManager.ItemType.Line, list20[num34].ID).ToUpper().Contains(searchInputField.text.ToUpper()))
|
|
{
|
|
SlotItem component20 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
|
|
component20.currentSlotIndex = currentSlotIndex;
|
|
component20.line = list20[num34];
|
|
component20.line.amount = list20[num34].amount;
|
|
component20.line.lenght = list20[num34].lenght;
|
|
component20.isBaitNatural = false;
|
|
component20.itemType = GameManager.ItemType.Line;
|
|
component20.deleteItemButton.gameObject.SetActive(value: true);
|
|
component20.SetupItem();
|
|
int gameItemIndexByItemId12 = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Line, list20[num34].ID);
|
|
component20.itemStatText.text = GameManager.Instance.ConvertWeight(GameManager.Instance.gameLines[gameItemIndexByItemId12].strength);
|
|
Text itemStatText8 = component20.itemStatText;
|
|
itemStatText8.text = itemStatText8.text + "\n" + GameManager.Instance.ConvertLenghtWithUnit(list20[num34].lenght, "F0");
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case GameManager.ItemType.Hook:
|
|
{
|
|
if (searchInputField.text.Length < 2)
|
|
{
|
|
List<GameManager.PlayerData.CHooks> list5 = new List<GameManager.PlayerData.CHooks>();
|
|
for (int num3 = 0; num3 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks.Count; num3++)
|
|
{
|
|
if (!list5.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num3]))
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num3].amount = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num3].amount;
|
|
list5.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num3]);
|
|
}
|
|
}
|
|
for (int num4 = 0; num4 < list5.Count; num4++)
|
|
{
|
|
SlotItem component5 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
|
|
component5.currentSlotIndex = currentSlotIndex;
|
|
component5.hook = list5[num4];
|
|
component5.hook.amount = list5[num4].amount;
|
|
component5.isBaitNatural = false;
|
|
component5.itemType = GameManager.ItemType.Hook;
|
|
component5.deleteItemButton.gameObject.SetActive(value: true);
|
|
component5.SetupItem();
|
|
int gameItemIndexByItemId3 = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Hook, list5[num4].ID);
|
|
component5.itemStatText.text = GameManager.Instance.gameHooks[gameItemIndexByItemId3].GetSizetext();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
List<GameManager.PlayerData.CHooks> list6 = new List<GameManager.PlayerData.CHooks>();
|
|
for (int num5 = 0; num5 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks.Count; num5++)
|
|
{
|
|
if (!list6.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num5]))
|
|
{
|
|
list6.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num5]);
|
|
}
|
|
}
|
|
for (int num6 = 0; num6 < list6.Count; num6++)
|
|
{
|
|
if (GameManager.Instance.GetGameItemName(GameManager.ItemType.Hook, list6[num6].ID).ToUpper().Contains(searchInputField.text.ToUpper()))
|
|
{
|
|
SlotItem component6 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
|
|
component6.currentSlotIndex = currentSlotIndex;
|
|
component6.hook = list6[num6];
|
|
component6.hook.amount = list6[num6].amount;
|
|
component6.isBaitNatural = false;
|
|
component6.itemType = GameManager.ItemType.Hook;
|
|
component6.deleteItemButton.gameObject.SetActive(value: true);
|
|
component6.SetupItem();
|
|
int gameItemIndexByItemId4 = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Hook, list6[num6].ID);
|
|
component6.itemStatText.text = GameManager.Instance.gameHooks[gameItemIndexByItemId4].GetSizetext();
|
|
}
|
|
}
|
|
}
|
|
if (!searchInputField.text.StartsWith("#") || searchInputField.text.Length < 2)
|
|
{
|
|
break;
|
|
}
|
|
if (searchInputField.text.Length < 2)
|
|
{
|
|
List<GameManager.PlayerData.CHooks> list7 = new List<GameManager.PlayerData.CHooks>();
|
|
for (int num7 = 0; num7 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks.Count; num7++)
|
|
{
|
|
if (!list7.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num7]))
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num7].amount = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num7].amount;
|
|
list7.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num7]);
|
|
}
|
|
}
|
|
for (int num8 = 0; num8 < list7.Count; num8++)
|
|
{
|
|
SlotItem component7 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
|
|
component7.currentSlotIndex = currentSlotIndex;
|
|
component7.hook = list7[num8];
|
|
component7.hook.amount = list7[num8].amount;
|
|
component7.isBaitNatural = false;
|
|
component7.itemType = GameManager.ItemType.Hook;
|
|
component7.deleteItemButton.gameObject.SetActive(value: true);
|
|
component7.SetupItem();
|
|
int gameItemIndexByItemId5 = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Hook, list7[num8].ID);
|
|
component7.itemStatText.text = GameManager.Instance.gameHooks[gameItemIndexByItemId5].GetSizetext();
|
|
}
|
|
break;
|
|
}
|
|
List<GameManager.PlayerData.CHooks> list8 = new List<GameManager.PlayerData.CHooks>();
|
|
for (int num9 = 0; num9 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks.Count; num9++)
|
|
{
|
|
if (!list8.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num9]))
|
|
{
|
|
list8.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num9]);
|
|
}
|
|
}
|
|
for (int num10 = 0; num10 < list8.Count; num10++)
|
|
{
|
|
if (GameManager.Instance.GetGameItemName(GameManager.ItemType.Hook, list8[num10].ID).ToUpper().Contains(searchInputField.text.ToUpper()))
|
|
{
|
|
SlotItem component8 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
|
|
component8.currentSlotIndex = currentSlotIndex;
|
|
component8.hook = list8[num10];
|
|
component8.hook.amount = list8[num10].amount;
|
|
component8.isBaitNatural = false;
|
|
component8.itemType = GameManager.ItemType.Hook;
|
|
component8.deleteItemButton.gameObject.SetActive(value: true);
|
|
component8.SetupItem();
|
|
int gameItemIndexByItemId6 = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Hook, list8[num10].ID);
|
|
component8.itemStatText.text = GameManager.Instance.gameHooks[gameItemIndexByItemId6].GetSizetext();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case GameManager.ItemType.Float:
|
|
{
|
|
if (searchInputField.text.Length < 2)
|
|
{
|
|
List<GameManager.PlayerData.CFloats> list15 = new List<GameManager.PlayerData.CFloats>();
|
|
for (int num23 = 0; num23 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats.Count; num23++)
|
|
{
|
|
if (!list15.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[num23]))
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[num23].amount = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[num23].amount;
|
|
list15.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[num23]);
|
|
}
|
|
}
|
|
for (int num24 = 0; num24 < list15.Count; num24++)
|
|
{
|
|
SlotItem component15 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
|
|
component15.currentSlotIndex = currentSlotIndex;
|
|
component15.ffloat = list15[num24];
|
|
component15.ffloat.amount = list15[num24].amount;
|
|
component15.isBaitNatural = false;
|
|
component15.itemType = GameManager.ItemType.Float;
|
|
component15.deleteItemButton.gameObject.SetActive(value: true);
|
|
component15.SetupItem();
|
|
int gameItemIndexByItemId7 = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Float, list15[num24].ID);
|
|
component15.itemStatText.text = GameManager.Instance.gameFloats[gameItemIndexByItemId7].displacement.ToString("F0") + "g";
|
|
}
|
|
break;
|
|
}
|
|
List<GameManager.PlayerData.CFloats> list16 = new List<GameManager.PlayerData.CFloats>();
|
|
for (int num25 = 0; num25 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats.Count; num25++)
|
|
{
|
|
if (!list16.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[num25]))
|
|
{
|
|
list16.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[num25]);
|
|
}
|
|
}
|
|
for (int num26 = 0; num26 < list16.Count; num26++)
|
|
{
|
|
if (GameManager.Instance.GetGameItemName(GameManager.ItemType.Float, list16[num26].ID).ToUpper().Contains(searchInputField.text.ToUpper()))
|
|
{
|
|
SlotItem component16 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
|
|
component16.currentSlotIndex = currentSlotIndex;
|
|
component16.ffloat = list16[num26];
|
|
component16.ffloat.amount = list16[num26].amount;
|
|
component16.isBaitNatural = false;
|
|
component16.itemType = GameManager.ItemType.Float;
|
|
component16.deleteItemButton.gameObject.SetActive(value: true);
|
|
component16.SetupItem();
|
|
int gameItemIndexByItemId8 = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Float, list16[num26].ID);
|
|
component16.itemStatText.text = GameManager.Instance.gameFloats[gameItemIndexByItemId8].displacement.ToString("F0") + "g";
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case GameManager.ItemType.Feeder:
|
|
{
|
|
if (searchInputField.text.Length < 2)
|
|
{
|
|
List<GameManager.PlayerData.CFeeders> list3 = new List<GameManager.PlayerData.CFeeders>();
|
|
for (int m = 0; m < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders.Count; m++)
|
|
{
|
|
if (!list3.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[m]))
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[m].amount = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[m].amount;
|
|
list3.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[m]);
|
|
}
|
|
}
|
|
for (int n = 0; n < list3.Count; n++)
|
|
{
|
|
SlotItem component3 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
|
|
component3.currentSlotIndex = currentSlotIndex;
|
|
component3.feeder = list3[n];
|
|
component3.feeder.amount = list3[n].amount;
|
|
component3.isBaitNatural = false;
|
|
component3.itemType = GameManager.ItemType.Feeder;
|
|
component3.deleteItemButton.gameObject.SetActive(value: true);
|
|
component3.SetupItem();
|
|
int gameItemIndexByItemId = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Feeder, list3[n].ID);
|
|
component3.itemStatText.text = GameManager.Instance.gameFeeders[gameItemIndexByItemId].weight.ToString("F0") + "g";
|
|
}
|
|
break;
|
|
}
|
|
List<GameManager.PlayerData.CFeeders> list4 = new List<GameManager.PlayerData.CFeeders>();
|
|
for (int num = 0; num < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders.Count; num++)
|
|
{
|
|
if (!list4.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[num]))
|
|
{
|
|
list4.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[num]);
|
|
}
|
|
}
|
|
for (int num2 = 0; num2 < list4.Count; num2++)
|
|
{
|
|
if (GameManager.Instance.GetGameItemName(GameManager.ItemType.Feeder, list4[num2].ID).ToUpper().Contains(searchInputField.text.ToUpper()))
|
|
{
|
|
SlotItem component4 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
|
|
component4.currentSlotIndex = currentSlotIndex;
|
|
component4.feeder = list4[num2];
|
|
component4.feeder.amount = list4[num2].amount;
|
|
component4.isBaitNatural = false;
|
|
component4.itemType = GameManager.ItemType.Feeder;
|
|
component4.deleteItemButton.gameObject.SetActive(value: true);
|
|
component4.SetupItem();
|
|
int gameItemIndexByItemId2 = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Feeder, list4[num2].ID);
|
|
component4.itemStatText.text = GameManager.Instance.gameFeeders[gameItemIndexByItemId2].weight.ToString("F0") + "g";
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case GameManager.ItemType.Rod:
|
|
{
|
|
if (searchInputField.text.Length < 2)
|
|
{
|
|
List<GameManager.PlayerData.CRods> list21 = new List<GameManager.PlayerData.CRods>();
|
|
for (int num35 = 0; num35 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods.Count; num35++)
|
|
{
|
|
if (!list21.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num35]))
|
|
{
|
|
GameManager.PlayerData.CRods cRods = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num35];
|
|
cRods.amount = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num35].amount;
|
|
cRods.status = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num35].status;
|
|
list21.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num35]);
|
|
}
|
|
}
|
|
for (int num36 = 0; num36 < list21.Count; num36++)
|
|
{
|
|
SlotItem component21 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
|
|
component21.currentSlotIndex = currentSlotIndex;
|
|
component21.rod = list21[num36];
|
|
component21.rod.amount = list21[num36].amount;
|
|
component21.isBaitNatural = false;
|
|
component21.itemType = GameManager.ItemType.Rod;
|
|
component21.deleteItemButton.gameObject.SetActive(value: true);
|
|
component21.SetupItem();
|
|
int gameItemIndexByItemId13 = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Line, list21[num36].ID);
|
|
if (float.TryParse(GameManager.Instance.gameRods[gameItemIndexByItemId13].length.Replace(',', '.'), out var result))
|
|
{
|
|
component21.itemStatText.text = GameManager.Instance.ConvertLenghtWithUnit(result);
|
|
}
|
|
Text itemStatText9 = component21.itemStatText;
|
|
itemStatText9.text = itemStatText9.text + "\n" + GameManager.Instance.ConvertWeight(GameManager.Instance.gameRods[gameItemIndexByItemId13].strength);
|
|
}
|
|
break;
|
|
}
|
|
List<GameManager.PlayerData.CRods> list22 = new List<GameManager.PlayerData.CRods>();
|
|
for (int num37 = 0; num37 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods.Count; num37++)
|
|
{
|
|
if (!list22.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num37]))
|
|
{
|
|
list22.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num37]);
|
|
}
|
|
}
|
|
for (int num38 = 0; num38 < list22.Count; num38++)
|
|
{
|
|
if (GameManager.Instance.GetGameItemName(GameManager.ItemType.Rod, list22[num38].ID).ToUpper().Contains(searchInputField.text.ToUpper()))
|
|
{
|
|
SlotItem component22 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
|
|
component22.currentSlotIndex = currentSlotIndex;
|
|
component22.rod = list22[num38];
|
|
component22.rod.amount = list22[num38].amount;
|
|
component22.isBaitNatural = false;
|
|
component22.itemType = GameManager.ItemType.Rod;
|
|
component22.deleteItemButton.gameObject.SetActive(value: true);
|
|
component22.SetupItem();
|
|
int gameItemIndexByItemId14 = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Line, list22[num38].ID);
|
|
if (float.TryParse(GameManager.Instance.gameRods[gameItemIndexByItemId14].length.Replace(',', '.'), out var result2))
|
|
{
|
|
component22.itemStatText.text = GameManager.Instance.ConvertLenghtWithUnit(result2);
|
|
}
|
|
Text itemStatText10 = component22.itemStatText;
|
|
itemStatText10.text = itemStatText10.text + "\n" + GameManager.Instance.ConvertWeight(GameManager.Instance.gameRods[gameItemIndexByItemId14].strength);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case GameManager.ItemType.Accesories:
|
|
{
|
|
if (searchInputField.text.Length < 2)
|
|
{
|
|
List<GameManager.PlayerData.CAccesories> list = new List<GameManager.PlayerData.CAccesories>();
|
|
for (int i = 0; i < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories.Count; i++)
|
|
{
|
|
if (!list.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[i]))
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[i].amount = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[i].amount;
|
|
list.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[i]);
|
|
}
|
|
}
|
|
for (int j = 0; j < list.Count; j++)
|
|
{
|
|
SlotItem component = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
|
|
component.isBaitNatural = false;
|
|
component.currentSlotIndex = 0;
|
|
component.gameItemIndex = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Accesories, list[j].ID);
|
|
component.itemUniqueId = list[j].uniqueId;
|
|
component.itemType = GameManager.ItemType.Accesories;
|
|
component.deleteItemButton.gameObject.SetActive(value: true);
|
|
component.SetupItem();
|
|
component.itemIconImage.sprite = GameManager.Instance.gameAccesories[component.gameItemIndex].GetIconImage();
|
|
component.itemNameText.text = GameManager.Instance.gameAccesories[component.gameItemIndex].GetName();
|
|
component.itemStatText.text = "";
|
|
}
|
|
break;
|
|
}
|
|
List<GameManager.PlayerData.CAccesories> list2 = new List<GameManager.PlayerData.CAccesories>();
|
|
for (int k = 0; k < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories.Count; k++)
|
|
{
|
|
if (!list2.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[k]))
|
|
{
|
|
list2.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[k]);
|
|
}
|
|
}
|
|
for (int l = 0; l < list2.Count; l++)
|
|
{
|
|
if (GameManager.Instance.GetGameItemName(GameManager.ItemType.Accesories, list2[l].ID).ToUpper().Contains(searchInputField.text.ToUpper()))
|
|
{
|
|
SlotItem component2 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
|
|
component2.isBaitNatural = false;
|
|
component2.currentSlotIndex = 0;
|
|
component2.gameItemIndex = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Accesories, list2[l].ID);
|
|
component2.itemUniqueId = list2[l].uniqueId;
|
|
component2.itemType = GameManager.ItemType.Accesories;
|
|
component2.deleteItemButton.gameObject.SetActive(value: true);
|
|
component2.SetupItem();
|
|
component2.itemIconImage.sprite = GameManager.Instance.gameAccesories[component2.gameItemIndex].GetIconImage();
|
|
component2.itemNameText.text = GameManager.Instance.gameAccesories[component2.gameItemIndex].GetName();
|
|
component2.itemStatText.text = "";
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void OnChangeSort()
|
|
{
|
|
dropdownIndex = sortDropdown.value;
|
|
SortFilter(dropdownIndex);
|
|
}
|
|
|
|
private void SortFilter(int indexSort)
|
|
{
|
|
List<SlotItem> list = new List<SlotItem>();
|
|
list.AddRange(popupItems.GetComponentsInChildren<SlotItem>());
|
|
if (itemsDisplayType == GameManager.ItemType.Rod || itemsDisplayType == GameManager.ItemType.Reel || itemsDisplayType == GameManager.ItemType.Line || itemsDisplayType == GameManager.ItemType.Leader)
|
|
{
|
|
switch (indexSort)
|
|
{
|
|
case 0:
|
|
popupItemsContent.GetComponent<EquipPopup>().RefreshSort();
|
|
return;
|
|
case 1:
|
|
list.Sort(CompareListByLevel);
|
|
break;
|
|
case 2:
|
|
list.Sort(CompareListByName);
|
|
break;
|
|
case 3:
|
|
list.Sort(CompareListByStrength);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (indexSort)
|
|
{
|
|
case 0:
|
|
popupItemsContent.GetComponent<EquipPopup>().RefreshSort();
|
|
return;
|
|
case 1:
|
|
list.Sort(CompareListByLevel);
|
|
break;
|
|
case 2:
|
|
list.Sort(CompareListByName);
|
|
break;
|
|
}
|
|
}
|
|
for (int i = 0; i < list.Count; i++)
|
|
{
|
|
list[i].transform.SetSiblingIndex(i);
|
|
}
|
|
}
|
|
|
|
private int CompareListByName(SlotItem i1, SlotItem i2)
|
|
{
|
|
return i1.itemNameText.text.CompareTo(i2.itemNameText.text);
|
|
}
|
|
|
|
private int CompareListByStrength(SlotItem i1, SlotItem i2)
|
|
{
|
|
return itemsDisplayType switch
|
|
{
|
|
GameManager.ItemType.Rod => GameManager.Instance.gameRods[i1.gameItemIndex].strength.CompareTo(GameManager.Instance.gameRods[i2.gameItemIndex].strength),
|
|
GameManager.ItemType.Reel => GameManager.Instance.gameReels[i1.gameItemIndex].strength.CompareTo(GameManager.Instance.gameReels[i2.gameItemIndex].strength),
|
|
GameManager.ItemType.Line => GameManager.Instance.gameLines[i1.gameItemIndex].strength.CompareTo(GameManager.Instance.gameLines[i2.gameItemIndex].strength),
|
|
GameManager.ItemType.Leader => GameManager.Instance.gameLeaders[i1.gameItemIndex].strength.CompareTo(GameManager.Instance.gameLeaders[i2.gameItemIndex].strength),
|
|
_ => 0,
|
|
};
|
|
}
|
|
|
|
private int CompareListByLevel(SlotItem i1, SlotItem i2)
|
|
{
|
|
return itemsDisplayType switch
|
|
{
|
|
GameManager.ItemType.Bait => GameManager.Instance.gameBaits[i1.gameItemIndex].Level.CompareTo(GameManager.Instance.gameBaits[i2.gameItemIndex].Level),
|
|
GameManager.ItemType.Reel => GameManager.Instance.gameReels[i1.gameItemIndex].Level.CompareTo(GameManager.Instance.gameReels[i2.gameItemIndex].Level),
|
|
GameManager.ItemType.Rod => GameManager.Instance.gameRods[i1.gameItemIndex].Level.CompareTo(GameManager.Instance.gameRods[i2.gameItemIndex].Level),
|
|
GameManager.ItemType.Line => GameManager.Instance.gameLines[i1.gameItemIndex].Level.CompareTo(GameManager.Instance.gameLines[i2.gameItemIndex].Level),
|
|
GameManager.ItemType.Weight => GameManager.Instance.gameWeights[i1.gameItemIndex].Level.CompareTo(GameManager.Instance.gameWeights[i2.gameItemIndex].Level),
|
|
GameManager.ItemType.Leader => GameManager.Instance.gameLeaders[i1.gameItemIndex].Level.CompareTo(GameManager.Instance.gameLeaders[i2.gameItemIndex].Level),
|
|
GameManager.ItemType.Hook => GameManager.Instance.gameHooks[i1.gameItemIndex].Level.CompareTo(GameManager.Instance.gameHooks[i2.gameItemIndex].Level),
|
|
GameManager.ItemType.Feeder => GameManager.Instance.gameFeeders[i1.gameItemIndex].Level.CompareTo(GameManager.Instance.gameFeeders[i2.gameItemIndex].Level),
|
|
GameManager.ItemType.Float => GameManager.Instance.gameFloats[i1.gameItemIndex].Level.CompareTo(GameManager.Instance.gameFloats[i2.gameItemIndex].Level),
|
|
GameManager.ItemType.Accesories => GameManager.Instance.gameAccesories[i1.gameItemIndex].Level.CompareTo(GameManager.Instance.gameAccesories[i2.gameItemIndex].Level),
|
|
_ => -1,
|
|
};
|
|
}
|
|
|
|
public void BuildDropDown()
|
|
{
|
|
dropDownOptions.Clear();
|
|
sortDropdown.ClearOptions();
|
|
Dropdown.OptionData optionData = new Dropdown.OptionData();
|
|
optionData.text = LanguageManager.Instance.GetText("SORT_BY_DATE");
|
|
Dropdown.OptionData optionData2 = new Dropdown.OptionData();
|
|
optionData2.text = LanguageManager.Instance.GetText("SORT_BY_LEVEL");
|
|
Dropdown.OptionData optionData3 = new Dropdown.OptionData();
|
|
optionData3.text = LanguageManager.Instance.GetText("SORT_BY_NAME");
|
|
dropDownOptions.Add(optionData);
|
|
dropDownOptions.Add(optionData2);
|
|
dropDownOptions.Add(optionData3);
|
|
sortDropdown.AddOptions(dropDownOptions);
|
|
}
|
|
}
|