1176 lines
40 KiB
C#
1176 lines
40 KiB
C#
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using BitStrap;
|
|
using UIWidgets;
|
|
using UnityEngine;
|
|
using UnityEngine.UI;
|
|
|
|
public class EquipmentGUI : MonoBehaviour
|
|
{
|
|
[Header("Current Equipment")]
|
|
public List<EquipmentCurrentObject> equipmentCurrentObjects = new List<EquipmentCurrentObject>(13);
|
|
|
|
public List<EquipmentCurrentObject> equipmentCurrentBaits = new List<EquipmentCurrentObject>(3);
|
|
|
|
public List<GameObject> tabsOnlyNormal = new List<GameObject>();
|
|
|
|
public List<GameObject> tabsOnlyIce = new List<GameObject>();
|
|
|
|
public List<EquipmentCategoryButton> tabsCategories = new List<EquipmentCategoryButton>();
|
|
|
|
public List<GameObject> tabsSubCategories = new List<GameObject>();
|
|
|
|
public GameObject hookAndBaitsWindow;
|
|
|
|
public GameObject floatWeightWidget;
|
|
|
|
public GameObject floatDepthWidget;
|
|
|
|
public EquipmentSizeSlider equipmentSizeSlider;
|
|
|
|
public Text totalDurabilityText;
|
|
|
|
[ReadOnly]
|
|
public bool showOnlyBought;
|
|
|
|
[ReadOnly]
|
|
[Space]
|
|
public bool isIceEquipment;
|
|
|
|
public GameObject equipmentNormalParent;
|
|
|
|
public GameObject equipmentIceParent;
|
|
|
|
public Button toggleEquipmentButton;
|
|
|
|
public bool canEquipmentBeChanged = true;
|
|
|
|
public bool canSetBeChanged = true;
|
|
|
|
public bool isCurrentSet = true;
|
|
|
|
[Header("Tabs")]
|
|
public Tabs tabs;
|
|
|
|
public LayoutDynamicFix layoutDynamicFix;
|
|
|
|
public List<EquipmentTileView> equipmentTileView = new List<EquipmentTileView>();
|
|
|
|
public List<EquipmentTypeButton> equipmentTypeButtons = new List<EquipmentTypeButton>();
|
|
|
|
[Header("Info Window")]
|
|
public ModelViewerManager modelViewerManager;
|
|
|
|
public GameObject infoParent;
|
|
|
|
public Image infoIcon;
|
|
|
|
public Image infoProducerIcon;
|
|
|
|
public Text infoName;
|
|
|
|
public Text infoDescription;
|
|
|
|
public Text infoAmount;
|
|
|
|
public List<EquipmentParameter> infoParameters = new List<EquipmentParameter>();
|
|
|
|
public Text infoBestFor;
|
|
|
|
public Text infoBestForLures;
|
|
|
|
private ScrollRect infoBestForScrollRect;
|
|
|
|
private ScrollRect infoBestForLuresScrollRect;
|
|
|
|
public GameObject infoPriceParent;
|
|
|
|
public GameObject infoLevelParent;
|
|
|
|
public Text infoPriceValue;
|
|
|
|
public Text infoLevelValue;
|
|
|
|
public Color requirementsColor = Color.red;
|
|
|
|
public Button infoBtnBuy;
|
|
|
|
public Button infoBtnEquip;
|
|
|
|
public Button infoBtnSell;
|
|
|
|
[ReadOnly]
|
|
public Text infoBtnSellText;
|
|
|
|
public List<Button> infoBtnEquipBaits = new List<Button>();
|
|
|
|
public Button infoBtnShow;
|
|
|
|
public Button changeEquipmentBtn;
|
|
|
|
[ReadOnly]
|
|
public EquipmentObject currentSelectedEquipment;
|
|
|
|
[Header("Message")]
|
|
public GameObject msgParent;
|
|
|
|
public Text msgText;
|
|
|
|
[HideInInspector]
|
|
public EquipmentManager equipmentManager;
|
|
|
|
[HideInInspector]
|
|
public PlayerSettingsMy playerSettings;
|
|
|
|
public void Awake()
|
|
{
|
|
infoParent.SetActive(false);
|
|
infoBtnBuy.interactable = false;
|
|
equipmentSizeSlider.gameObject.SetActive(false);
|
|
for (int i = 0; i < equipmentCurrentObjects.Count; i++)
|
|
{
|
|
if ((bool)equipmentCurrentObjects[i])
|
|
{
|
|
equipmentCurrentObjects[i].equipmentGUI = this;
|
|
}
|
|
}
|
|
for (int j = 0; j < equipmentCurrentBaits.Count; j++)
|
|
{
|
|
equipmentCurrentBaits[j].equipmentGUI = this;
|
|
}
|
|
equipmentTypeButtons = GetComponentsInChildren<EquipmentTypeButton>().ToList();
|
|
infoBtnSellText = infoBtnSell.GetComponentInChildren<Text>();
|
|
infoBestForScrollRect = infoBestFor.rectTransform.parent.parent.GetComponent<ScrollRect>();
|
|
infoBestForLuresScrollRect = infoBestForLures.rectTransform.parent.parent.GetComponent<ScrollRect>();
|
|
}
|
|
|
|
private void Start()
|
|
{
|
|
equipmentManager = GlobalSettings.Instance.equipmentManager;
|
|
playerSettings = GlobalSettings.Instance.playerSettings;
|
|
floatDepthWidget.GetComponent<FloatParamWidget>().equipmentGUI = this;
|
|
floatWeightWidget.GetComponent<FloatParamWidget>().equipmentGUI = this;
|
|
isIceEquipment = true;
|
|
ToggleEquipment();
|
|
RefreshList(false);
|
|
tabs.Initialize();
|
|
for (int i = 0; i < equipmentTileView.Count; i++)
|
|
{
|
|
MenuManager.Instance.rightStickScrollbars.Add(equipmentTileView[i].ScrollRect.verticalScrollbar);
|
|
}
|
|
OnEnable();
|
|
}
|
|
|
|
private void OnEnable()
|
|
{
|
|
if ((bool)equipmentManager)
|
|
{
|
|
equipmentManager.CheckStartEquipment();
|
|
UpdateCanEquipmentBeChanged();
|
|
RefreshAll();
|
|
DeselectedEquipment();
|
|
if (!GameController.Instance)
|
|
{
|
|
equipmentManager.ResetChanged();
|
|
ResetChanged();
|
|
}
|
|
else if (!equipmentManager.HasAnythingChanged())
|
|
{
|
|
ResetChanged();
|
|
}
|
|
if ((bool)GameController.Instance)
|
|
{
|
|
SetEquipmentType(GameController.Instance.iceLevel);
|
|
}
|
|
CheckFloatArtificialBait();
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
infoBtnEquipBaits[i].GetComponentInChildren<Text>().text = Utilities.GetTranslation("GUI/BTN_EQUIP") + "\n" + Utilities.GetTranslation("EQUIPMENT/BAIT") + " " + (i + 1);
|
|
}
|
|
}
|
|
msgText.text = string.Empty;
|
|
}
|
|
|
|
private void OnDisable()
|
|
{
|
|
CheckFloatArtificialBait();
|
|
if ((bool)GameController.Instance && equipmentManager.HasAnythingChanged())
|
|
{
|
|
ChangeEquipment();
|
|
}
|
|
else if ((bool)HUDManager.Instance)
|
|
{
|
|
HUDManager.Instance.hudBaits.Refresh(HUDManager.Instance.fishingPlayer.currentHands);
|
|
}
|
|
if ((bool)equipmentManager && (bool)GlobalSettings.Instance && GlobalSettings.Instance.saveManager.isProfileLoaded)
|
|
{
|
|
equipmentManager.Save();
|
|
playerSettings.Save();
|
|
}
|
|
}
|
|
|
|
public void RefreshList(bool onlyBought)
|
|
{
|
|
if (equipmentManager == null)
|
|
{
|
|
return;
|
|
}
|
|
for (int i = 0; i < equipmentTileView.Count; i++)
|
|
{
|
|
equipmentTileView[i].Clear();
|
|
List<EquipmentObject> list = null;
|
|
list = equipmentManager.GetEquipmentSpecificList(equipmentTileView[i].equipmentTileViewParameters);
|
|
if (list[0].equipmentType == EquipmentObject.EquipmentType.BAIT)
|
|
{
|
|
list.Sort((EquipmentObject f1, EquipmentObject f2) => f1.prefab.GetComponent<BaitPart>().priceFactor.CompareTo(f2.prefab.GetComponent<BaitPart>().priceFactor));
|
|
}
|
|
else
|
|
{
|
|
list.Sort((EquipmentObject f1, EquipmentObject f2) => f1.price.CompareTo(f2.price));
|
|
}
|
|
foreach (EquipmentObject item in list)
|
|
{
|
|
if ((!onlyBought || item.amount != 0 || item.isEquipped) && (!item.onlyCheat || GlobalSettings.Instance.turnOnCheats) && (!item.onlyBeta || GlobalSettings.Instance.isBeta) && (item.isAvailable || GlobalSettings.Instance.turnOnMyCheats) && (!GlobalSettings.Instance.isDemo || item.isInDemo))
|
|
{
|
|
EquipmentTileViewItem equipmentTileViewItem = new EquipmentTileViewItem();
|
|
equipmentTileViewItem.icon = item.icon;
|
|
equipmentTileViewItem.equipmentName = item.GetFullName();
|
|
equipmentTileViewItem.equipmentId = item.id;
|
|
equipmentTileViewItem.equipmentObject = item;
|
|
equipmentTileView[i].Add(equipmentTileViewItem);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void OnSelectObject(int index, ListViewItem item)
|
|
{
|
|
RefreshInfo();
|
|
RefreshMessage();
|
|
}
|
|
|
|
public void RefreshInfo(EquipmentObject selectedEquipment = null)
|
|
{
|
|
currentSelectedEquipment = selectedEquipment;
|
|
bool flag = selectedEquipment != null;
|
|
if (selectedEquipment == null)
|
|
{
|
|
selectedEquipment = GetSelectedEquipment();
|
|
}
|
|
if (selectedEquipment != null && !selectedEquipment.isAvailableFromDLCs && selectedEquipment.fromDLC.Count > 0)
|
|
{
|
|
DLCManager.Instance.BuyDLC(selectedEquipment.fromDLC[0]);
|
|
selectedEquipment = null;
|
|
}
|
|
infoParent.SetActive(selectedEquipment != null);
|
|
infoBtnShow.gameObject.SetActive(selectedEquipment != null);
|
|
bool flag2 = true;
|
|
bool flag3 = true;
|
|
bool flag4 = true;
|
|
RefreshEquipmentParameters(selectedEquipment);
|
|
if (selectedEquipment == null)
|
|
{
|
|
infoIcon.sprite = null;
|
|
infoProducerIcon.sprite = null;
|
|
infoName.text = string.Empty;
|
|
infoDescription.text = string.Empty;
|
|
infoBestFor.text = string.Empty;
|
|
infoBestForLures.text = string.Empty;
|
|
infoPriceParent.SetActive(false);
|
|
infoLevelParent.SetActive(false);
|
|
equipmentSizeSlider.gameObject.SetActive(false);
|
|
flag3 = false;
|
|
flag4 = false;
|
|
flag2 = false;
|
|
infoBtnSellText.text = Utilities.GetTranslation("GUI/BTN_SELL");
|
|
}
|
|
else
|
|
{
|
|
infoIcon.sprite = selectedEquipment.icon;
|
|
infoProducerIcon.sprite = selectedEquipment.producerIcon;
|
|
infoName.text = selectedEquipment.GetFullName();
|
|
infoDescription.text = Utilities.GetTranslation(selectedEquipment.description);
|
|
infoDescription.text = string.Empty;
|
|
infoPriceValue.text = string.Empty + selectedEquipment.GetCurrentSellPrice() + " $";
|
|
infoLevelValue.text = string.Empty + selectedEquipment.level;
|
|
infoPriceValue.color = ((!CheckPrice(selectedEquipment)) ? requirementsColor : Color.white);
|
|
infoLevelValue.color = ((!CheckLevel(selectedEquipment)) ? requirementsColor : Color.white);
|
|
if (selectedEquipment.equipmentType == EquipmentObject.EquipmentType.HOOK && IsEquippedInCurrentSet(selectedEquipment))
|
|
{
|
|
SetEquipmentSliderActive(true, selectedEquipment);
|
|
}
|
|
else
|
|
{
|
|
SetEquipmentSliderActive(false);
|
|
}
|
|
infoBtnSellText.text = Utilities.GetTranslation("GUI/BTN_SELL") + " +" + Mathf.RoundToInt((float)selectedEquipment.price * equipmentManager.sellObjectFactor) + " $";
|
|
if (selectedEquipment.hasAmount)
|
|
{
|
|
infoPriceParent.SetActive(true);
|
|
infoLevelParent.SetActive(true);
|
|
flag3 = selectedEquipment.amount < selectedEquipment.maxAmount && CheckPrice(selectedEquipment) && CheckLevel(selectedEquipment);
|
|
flag4 = ((!equipmentManager.IsThisStartEquipment(selectedEquipment)) ? (selectedEquipment.amount > 0) : (selectedEquipment.amount > 1 || (selectedEquipment.isEquipped && selectedEquipment.amount > 0)));
|
|
flag2 = (IsEquipmentWithAmount(selectedEquipment.equipmentType) ? (selectedEquipment.amount > 0 && !IsEquippedInCurrentSet(selectedEquipment)) : ((selectedEquipment.equipmentType != EquipmentObject.EquipmentType.OTHER || selectedEquipment.equipmentSubType != EquipmentObject.EquipmentSubType.FLOAT_WEIGHT) && ((selectedEquipment.equipmentType != EquipmentObject.EquipmentType.BAIT) ? (selectedEquipment.amount > 0 && selectedEquipment.equipmentType != EquipmentObject.EquipmentType.OTHER) : (selectedEquipment.amount > 0))));
|
|
if (selectedEquipment.equipmentType == EquipmentObject.EquipmentType.BITE_INDICATOR && (bool)GameController.Instance && GameController.Instance.iceLevel)
|
|
{
|
|
flag2 = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
infoPriceParent.SetActive(!selectedEquipment.isBought);
|
|
infoLevelParent.SetActive(true);
|
|
flag3 = !selectedEquipment.isBought && CheckPrice(selectedEquipment) && CheckLevel(selectedEquipment);
|
|
flag4 = selectedEquipment.isBought && !selectedEquipment.isEquipped && selectedEquipment.canBeSold;
|
|
flag2 = selectedEquipment.equipmentSubType != EquipmentObject.EquipmentSubType.DRILLER && selectedEquipment.equipmentSubType != EquipmentObject.EquipmentSubType.FISHING_NET && selectedEquipment.equipmentSubType != EquipmentObject.EquipmentSubType.GAS_STOVE && selectedEquipment.isBought && !selectedEquipment.isEquipped;
|
|
}
|
|
infoAmount.text = selectedEquipment.amount.ToString();
|
|
infoAmount.gameObject.SetActive(selectedEquipment.hasAmount);
|
|
if (!canEquipmentBeChanged)
|
|
{
|
|
flag2 = false;
|
|
}
|
|
if (!flag4)
|
|
{
|
|
infoBtnSellText.text = Utilities.GetTranslation("GUI/BTN_SELL");
|
|
}
|
|
}
|
|
infoProducerIcon.gameObject.SetActive(infoProducerIcon.sprite != null);
|
|
if (flag)
|
|
{
|
|
flag2 = false;
|
|
}
|
|
if (playerSettings.IsSandbox())
|
|
{
|
|
flag3 = false;
|
|
flag4 = false;
|
|
}
|
|
UpdateEquipVisibility(flag2);
|
|
infoBtnBuy.interactable = flag3;
|
|
infoBtnSell.interactable = flag4;
|
|
infoBtnSell.GetComponent<ButtonDeselectFix>().DeselectFix();
|
|
infoBtnBuy.GetComponent<ButtonDeselectFix>().DeselectFix();
|
|
infoBtnEquip.GetComponent<ButtonDeselectFix>().DeselectFix();
|
|
for (int i = 0; i < infoBtnEquipBaits.Count; i++)
|
|
{
|
|
infoBtnEquipBaits[i].GetComponent<ButtonDeselectFix>().DeselectFix();
|
|
}
|
|
if (selectedEquipment != null && selectedEquipment.equipmentType == EquipmentObject.EquipmentType.BAIT)
|
|
{
|
|
infoBtnEquip.gameObject.SetActive(false);
|
|
infoBtnEquipBaits[0].transform.parent.gameObject.SetActive(true);
|
|
infoBtnEquipBaits[3].transform.parent.gameObject.SetActive(true);
|
|
}
|
|
else
|
|
{
|
|
infoBtnEquip.gameObject.SetActive(true);
|
|
infoBtnEquipBaits[0].transform.parent.gameObject.SetActive(false);
|
|
infoBtnEquipBaits[3].transform.parent.gameObject.SetActive(false);
|
|
}
|
|
if (selectedEquipment != null)
|
|
{
|
|
modelViewerManager.InstantiateObject(selectedEquipment);
|
|
}
|
|
else
|
|
{
|
|
modelViewerManager.InstantiateObject(null);
|
|
}
|
|
}
|
|
|
|
public void RemoveCurrent()
|
|
{
|
|
for (int i = 0; i < equipmentCurrentObjects.Count; i++)
|
|
{
|
|
equipmentCurrentObjects[i].RemoveObject();
|
|
}
|
|
for (int j = 0; j < equipmentCurrentBaits.Count; j++)
|
|
{
|
|
equipmentCurrentBaits[j].RemoveObject();
|
|
}
|
|
}
|
|
|
|
public void RefreshCurrent()
|
|
{
|
|
for (int i = 0; i < equipmentCurrentObjects.Count; i++)
|
|
{
|
|
equipmentCurrentObjects[i].Refresh();
|
|
}
|
|
for (int j = 0; j < equipmentCurrentBaits.Count; j++)
|
|
{
|
|
equipmentCurrentBaits[j].Refresh();
|
|
}
|
|
floatDepthWidget.GetComponent<FloatParamWidget>().Refresh();
|
|
floatWeightWidget.GetComponent<FloatParamWidget>().Refresh();
|
|
}
|
|
|
|
public void RefreshBaits()
|
|
{
|
|
int num = 0;
|
|
if (equipmentCurrentObjects[5].equipmentObject != null)
|
|
{
|
|
num = equipmentCurrentObjects[5].equipmentObject.prefab.GetComponent<Bait>().baitPartsMax;
|
|
}
|
|
for (int i = 0; i < equipmentCurrentBaits.Count; i++)
|
|
{
|
|
equipmentCurrentBaits[i].SetActive(i < num);
|
|
}
|
|
}
|
|
|
|
public void RefreshMessage()
|
|
{
|
|
string text = string.Empty;
|
|
EquipmentObject selectedEquipment = GetSelectedEquipment();
|
|
bool flag = equipmentCurrentObjects[4].equipmentObject != null && (bool)equipmentCurrentObjects[4].equipmentObject.prefab;
|
|
bool flag2 = selectedEquipment != null && selectedEquipment.equipmentType == EquipmentObject.EquipmentType.FLOAT;
|
|
bool flag3 = equipmentCurrentObjects[10].equipmentObject != null && (bool)equipmentCurrentObjects[10].equipmentObject.prefab;
|
|
bool flag4 = selectedEquipment != null && selectedEquipment.equipmentType == EquipmentObject.EquipmentType.FEEDER;
|
|
bool flag5 = equipmentCurrentObjects[5].equipmentObject != null && (bool)equipmentCurrentObjects[5].equipmentObject.prefab && equipmentCurrentObjects[5].equipmentObject.prefab.GetComponent<Bait>().baitType != Bait.BaitType.HOOK;
|
|
bool flag6 = selectedEquipment != null && selectedEquipment.equipmentType == EquipmentObject.EquipmentType.HOOK && selectedEquipment.prefab.GetComponent<Bait>().baitType != Bait.BaitType.HOOK;
|
|
bool flag7 = equipmentCurrentObjects[5].equipmentObject != null && (bool)equipmentCurrentObjects[5].equipmentObject.prefab && equipmentCurrentObjects[5].equipmentObject.prefab.GetComponent<Bait>().baitType == Bait.BaitType.HOOK;
|
|
bool flag8 = selectedEquipment != null && selectedEquipment.equipmentType == EquipmentObject.EquipmentType.HOOK && selectedEquipment.prefab.GetComponent<Bait>().baitType == Bait.BaitType.HOOK;
|
|
bool flag9 = selectedEquipment != null && selectedEquipment.equipmentType == EquipmentObject.EquipmentType.BAIT;
|
|
FishingRod fishingRod = null;
|
|
FishingRod fishingRod2 = null;
|
|
FishingReel fishingReel = null;
|
|
FishingReel fishingReel2 = null;
|
|
FishingLine fishingLine = null;
|
|
FishingLine fishingLine2 = null;
|
|
Bait bait = null;
|
|
Bait bait2 = null;
|
|
if (equipmentCurrentObjects[0].equipmentObject != null && (bool)equipmentCurrentObjects[0].equipmentObject.prefab)
|
|
{
|
|
fishingRod = equipmentCurrentObjects[0].equipmentObject.prefab.GetComponent<FishingRod>();
|
|
}
|
|
if (equipmentCurrentObjects[2].equipmentObject != null && (bool)equipmentCurrentObjects[2].equipmentObject.prefab)
|
|
{
|
|
fishingReel = equipmentCurrentObjects[2].equipmentObject.prefab.GetComponent<FishingReel>();
|
|
}
|
|
if (equipmentCurrentObjects[3].equipmentObject != null && (bool)equipmentCurrentObjects[3].equipmentObject.prefab)
|
|
{
|
|
fishingLine = equipmentCurrentObjects[3].equipmentObject.prefab.GetComponent<FishingLine>();
|
|
}
|
|
if (equipmentCurrentObjects[5].equipmentObject != null && (bool)equipmentCurrentObjects[5].equipmentObject.prefab)
|
|
{
|
|
bait = equipmentCurrentObjects[5].equipmentObject.prefab.GetComponent<Bait>();
|
|
}
|
|
if (selectedEquipment != null && selectedEquipment.equipmentType == EquipmentObject.EquipmentType.ROD)
|
|
{
|
|
fishingRod2 = selectedEquipment.prefab.GetComponent<FishingRod>();
|
|
}
|
|
if (selectedEquipment != null && selectedEquipment.equipmentType == EquipmentObject.EquipmentType.REEL)
|
|
{
|
|
fishingReel2 = selectedEquipment.prefab.GetComponent<FishingReel>();
|
|
}
|
|
if (selectedEquipment != null && selectedEquipment.equipmentType == EquipmentObject.EquipmentType.LINE)
|
|
{
|
|
fishingLine2 = selectedEquipment.prefab.GetComponent<FishingLine>();
|
|
}
|
|
if (selectedEquipment != null && selectedEquipment.equipmentType == EquipmentObject.EquipmentType.HOOK)
|
|
{
|
|
bait2 = selectedEquipment.prefab.GetComponent<Bait>();
|
|
}
|
|
bool flag10 = true;
|
|
if (selectedEquipment != null)
|
|
{
|
|
if (!isIceEquipment && ((flag && flag6) || (flag5 && flag2) || (flag3 && flag6) || (flag5 && flag4)))
|
|
{
|
|
text = Utilities.GetTranslation("EQUIPMENT/MSG_ARTIFICIAL_WITH_FLOAT");
|
|
flag10 = false;
|
|
}
|
|
else if (!isIceEquipment && ((flag && flag4) || (flag3 && flag2)))
|
|
{
|
|
text = Utilities.GetTranslation("EQUIPMENT/MSG_FLOATS_WITH_FEEDERS");
|
|
flag10 = false;
|
|
}
|
|
else if (!isIceEquipment && !flag && !flag3 && flag8)
|
|
{
|
|
text = Utilities.GetTranslation("EQUIPMENT/MSG_HOOK_WITHOUT_FLOAT");
|
|
flag10 = false;
|
|
}
|
|
else if (flag5 && flag9)
|
|
{
|
|
text = Utilities.GetTranslation("EQUIPMENT/MSG_ARTIFICIAL_WITH_NATURAL");
|
|
flag10 = false;
|
|
}
|
|
else if (((bool)fishingRod && fishingRod.rodType == FishingRod.RodType.FLY_FISHING && (bool)fishingReel2 && fishingReel2.reelType != FishingReel.ReelType.FLY) || ((bool)fishingRod && fishingRod.rodType != FishingRod.RodType.FLY_FISHING && (bool)fishingReel2 && fishingReel2.reelType == FishingReel.ReelType.FLY) || ((bool)fishingReel && fishingReel.reelType == FishingReel.ReelType.FLY && (bool)fishingRod2 && fishingRod2.rodType != FishingRod.RodType.FLY_FISHING) || ((bool)fishingReel && fishingReel.reelType != FishingReel.ReelType.FLY && (bool)fishingRod2 && fishingRod2.rodType == FishingRod.RodType.FLY_FISHING))
|
|
{
|
|
text = Utilities.GetTranslation("EQUIPMENT/MSG_FLY_EQUIPMENT_ROD_REEL");
|
|
flag10 = false;
|
|
}
|
|
else if (!isIceEquipment && (((bool)fishingLine && fishingLine.lineType == FishingLine.LineType.FLY && (bool)fishingReel2 && fishingReel2.reelType != FishingReel.ReelType.FLY) || ((bool)fishingLine && fishingLine.lineType != FishingLine.LineType.FLY && (bool)fishingReel2 && fishingReel2.reelType == FishingReel.ReelType.FLY) || ((bool)fishingReel && fishingReel.reelType == FishingReel.ReelType.FLY && (bool)fishingLine2 && fishingLine2.lineType != FishingLine.LineType.FLY) || ((bool)fishingReel && fishingReel.reelType != FishingReel.ReelType.FLY && (bool)fishingLine2 && fishingLine2.lineType == FishingLine.LineType.FLY)))
|
|
{
|
|
text = Utilities.GetTranslation("EQUIPMENT/MSG_FLY_EQUIPMENT_LINE_REEL");
|
|
flag10 = false;
|
|
}
|
|
else if (!isIceEquipment && (((bool)fishingLine && fishingLine.lineType == FishingLine.LineType.FLY && (bool)bait2 && bait2.baitType != Bait.BaitType.FLY) || ((bool)fishingLine && fishingLine.lineType != FishingLine.LineType.FLY && (bool)bait2 && bait2.baitType == Bait.BaitType.FLY) || ((bool)bait && bait.baitType == Bait.BaitType.FLY && (bool)fishingLine2 && fishingLine2.lineType != FishingLine.LineType.FLY) || ((bool)bait && bait.baitType != Bait.BaitType.FLY && (bool)fishingLine2 && fishingLine2.lineType == FishingLine.LineType.FLY)))
|
|
{
|
|
text = Utilities.GetTranslation("EQUIPMENT/MSG_FLY_EQUIPMENT_LINE_BAIT");
|
|
flag10 = false;
|
|
}
|
|
}
|
|
if (!canEquipmentBeChanged)
|
|
{
|
|
text = Utilities.GetTranslation("EQUIPMENT/MSG_CANT_CHANGE_FISHING");
|
|
}
|
|
if (!flag10)
|
|
{
|
|
UpdateEquipVisibility(false);
|
|
}
|
|
msgText.text = text;
|
|
}
|
|
|
|
public void CheckFloatArtificialBait()
|
|
{
|
|
bool flag = equipmentCurrentObjects[4].equipmentObject != null && (bool)equipmentCurrentObjects[4].equipmentObject.prefab;
|
|
bool flag2 = equipmentCurrentObjects[10].equipmentObject != null && (bool)equipmentCurrentObjects[10].equipmentObject.prefab;
|
|
bool flag3 = equipmentCurrentObjects[5].equipmentObject != null && (bool)equipmentCurrentObjects[5].equipmentObject.prefab && equipmentCurrentObjects[5].equipmentObject.prefab.GetComponent<Bait>().baitType != Bait.BaitType.HOOK;
|
|
bool flag4 = equipmentCurrentObjects[5].equipmentObject != null && (bool)equipmentCurrentObjects[5].equipmentObject.prefab && equipmentCurrentObjects[5].equipmentObject.prefab.GetComponent<Bait>().baitType == Bait.BaitType.HOOK;
|
|
if (isIceEquipment)
|
|
{
|
|
if ((flag || flag2) && flag3)
|
|
{
|
|
if (flag)
|
|
{
|
|
equipmentCurrentObjects[4].RemoveObject();
|
|
Debug.LogError("EQUIPMENT/MSG_ARTIFICIAL_WITH_FLOAT remove float");
|
|
}
|
|
if (flag2)
|
|
{
|
|
equipmentCurrentObjects[10].RemoveObject();
|
|
Debug.LogError("EQUIPMENT/MSG_ARTIFICIAL_WITH_FLOAT remove feeder");
|
|
}
|
|
msgText.text = Utilities.GetTranslation("EQUIPMENT/MSG_ARTIFICIAL_WITH_FLOAT");
|
|
}
|
|
}
|
|
else if ((flag || flag2) && flag3)
|
|
{
|
|
equipmentCurrentObjects[5].RemoveObject();
|
|
msgText.text = Utilities.GetTranslation("EQUIPMENT/MSG_ARTIFICIAL_WITH_FLOAT");
|
|
Debug.LogError("EQUIPMENT/MSG_ARTIFICIAL_WITH_FLOAT remove hook 1");
|
|
}
|
|
else if (!flag && !flag2 && flag4)
|
|
{
|
|
equipmentCurrentObjects[5].RemoveObject();
|
|
msgText.text = Utilities.GetTranslation("EQUIPMENT/MSG_ARTIFICIAL_WITH_FLOAT");
|
|
Debug.LogError("EQUIPMENT/MSG_ARTIFICIAL_WITH_FLOAT remove hook 2");
|
|
}
|
|
}
|
|
|
|
public void RefreshAll()
|
|
{
|
|
if (equipmentManager == null)
|
|
{
|
|
equipmentManager = GlobalSettings.Instance.equipmentManager;
|
|
}
|
|
if ((bool)equipmentManager)
|
|
{
|
|
RefreshInfo();
|
|
RefreshCurrent();
|
|
RefreshBaits();
|
|
RefreshMessage();
|
|
}
|
|
}
|
|
|
|
private void SetEquipmentSliderActive(bool active, EquipmentObject selectedEquipment = null)
|
|
{
|
|
if (active)
|
|
{
|
|
equipmentSizeSlider.equipmentObject = selectedEquipment;
|
|
equipmentSizeSlider.hookToWeightParameter = infoParameters[2];
|
|
equipmentSizeSlider.gameObject.SetActive(true);
|
|
equipmentSizeSlider.Refresh();
|
|
}
|
|
else
|
|
{
|
|
equipmentSizeSlider.gameObject.SetActive(false);
|
|
}
|
|
}
|
|
|
|
private EquipmentParameter GetEquipmentParameter(string name)
|
|
{
|
|
EquipmentParameter result = null;
|
|
int num = 0;
|
|
foreach (EquipmentParameter infoParameter in infoParameters)
|
|
{
|
|
if (infoParameter.nameText.text == name)
|
|
{
|
|
result = infoParameter;
|
|
}
|
|
Debug.Log("EquipmentParameter--------------------------------------------EquipmentParameter " + num + " --------- " + infoParameter.nameText.text);
|
|
num++;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private void SetHookToWeightParameter(EquipmentObject equipmentObject, EquipmentParameter hookToWeightParameter)
|
|
{
|
|
Bait component = equipmentObject.prefab.GetComponent<Bait>();
|
|
Debug.Log(string.Concat("------------bait -------------", component, " -------- hook to weight ", hookToWeightParameter));
|
|
if (component == null)
|
|
{
|
|
hookToWeightParameter.gameObject.SetActive(false);
|
|
return;
|
|
}
|
|
int index = (int)equipmentObject.sizes[(int)equipmentSizeSlider.slider.value];
|
|
FishManager fishManager = GlobalSettings.Instance.fishManager;
|
|
Vector2 one = Vector2.one;
|
|
one = ((component.baitType == Bait.BaitType.HOOK) ? fishManager.hookToFishWeight[index] : ((component.baitType != Bait.BaitType.FLY) ? fishManager.lureToFishWeight[index] : fishManager.flyToFishWeight[index]));
|
|
string paramValue = UtilitiesUnits.GetWeightString(one.x) + " - " + UtilitiesUnits.GetWeightString(one.y);
|
|
hookToWeightParameter.SetParameter(Utilities.GetTranslation("EQUIPMENT_PARAMETERS/HOOK_TO_WEIGHT"), paramValue);
|
|
}
|
|
|
|
public bool CheckPrice(EquipmentObject equipmentObject)
|
|
{
|
|
return equipmentObject.GetCurrentSellPrice() <= (int)playerSettings.playersMoney;
|
|
}
|
|
|
|
public bool CheckLevel(EquipmentObject equipmentObject)
|
|
{
|
|
return equipmentObject.level <= (int)playerSettings.playersLevel;
|
|
}
|
|
|
|
public void OnDeselectObject(int index, ListViewItem item)
|
|
{
|
|
}
|
|
|
|
public void BuyItem()
|
|
{
|
|
EquipmentObject selectedEquipment = GetSelectedEquipment();
|
|
if (selectedEquipment.equipmentType == EquipmentObject.EquipmentType.BAIT)
|
|
{
|
|
equipmentCurrentBaits[0].BuyObject(selectedEquipment);
|
|
}
|
|
else if (selectedEquipment.equipmentType == EquipmentObject.EquipmentType.OTHER)
|
|
{
|
|
equipmentManager.BuyObject(selectedEquipment);
|
|
}
|
|
else
|
|
{
|
|
equipmentCurrentObjects[(int)selectedEquipment.equipmentType].BuyObject(selectedEquipment);
|
|
}
|
|
RefreshInfo(currentSelectedEquipment);
|
|
RefreshMessage();
|
|
RefreshTileViews();
|
|
}
|
|
|
|
public void SellItem()
|
|
{
|
|
EquipmentObject selectedEquipment = GetSelectedEquipment();
|
|
if (selectedEquipment.equipmentType == EquipmentObject.EquipmentType.BAIT)
|
|
{
|
|
equipmentCurrentBaits[0].SellObject(selectedEquipment);
|
|
}
|
|
else if (selectedEquipment.equipmentType == EquipmentObject.EquipmentType.OTHER)
|
|
{
|
|
equipmentManager.SellObject(selectedEquipment);
|
|
}
|
|
else
|
|
{
|
|
equipmentCurrentObjects[(int)selectedEquipment.equipmentType].SellObject(selectedEquipment);
|
|
}
|
|
RefreshInfo(currentSelectedEquipment);
|
|
RefreshMessage();
|
|
RefreshTileViews();
|
|
if (selectedEquipment.amount == 0 && !selectedEquipment.isEquipped && showOnlyBought)
|
|
{
|
|
ShowOnlyBought(showOnlyBought);
|
|
}
|
|
}
|
|
|
|
public void EquipItem()
|
|
{
|
|
EquipmentObject selectedEquipment = GetSelectedEquipment();
|
|
if (selectedEquipment == null)
|
|
{
|
|
UpdateEquipVisibility(false);
|
|
Debug.LogError("EquipItem equipmentObject == null");
|
|
return;
|
|
}
|
|
if (selectedEquipment.equipmentType != EquipmentObject.EquipmentType.BAIT)
|
|
{
|
|
if (selectedEquipment.equipmentType == EquipmentObject.EquipmentType.HOOK)
|
|
{
|
|
if ((int)equipmentSizeSlider.slider.value < selectedEquipment.sizes.Count)
|
|
{
|
|
equipmentManager.currentSetSpecificParameters.currentHookSize = (int)selectedEquipment.sizes[(int)equipmentSizeSlider.slider.value];
|
|
}
|
|
else if (selectedEquipment.sizes.Count > 0)
|
|
{
|
|
equipmentManager.currentSetSpecificParameters.currentHookSize = (int)selectedEquipment.sizes[selectedEquipment.sizes.Count - 1];
|
|
}
|
|
else
|
|
{
|
|
equipmentManager.currentSetSpecificParameters.currentHookSize = 0f;
|
|
}
|
|
}
|
|
EquipmentCurrentObject equipmentCurrentObject = equipmentCurrentObjects[(int)selectedEquipment.equipmentType];
|
|
if (IsEquipmentWithAmount(selectedEquipment.equipmentType) && equipmentCurrentObject.equipmentObject != null)
|
|
{
|
|
equipmentCurrentObject.RemoveObject();
|
|
}
|
|
equipmentCurrentObject.ShowEquipmentChanged(true);
|
|
equipmentCurrentObject.EquipObject(selectedEquipment);
|
|
}
|
|
RefreshBaits();
|
|
RefreshInfo();
|
|
RefreshTotalDurability();
|
|
RefreshMessage();
|
|
RefreshTileViews();
|
|
CheckFloatArtificialBait();
|
|
if (isCurrentSet && canEquipmentBeChanged)
|
|
{
|
|
equipmentManager.EquipmentChanged(selectedEquipment.equipmentType);
|
|
}
|
|
if (selectedEquipment.equipmentType == EquipmentObject.EquipmentType.FLOAT)
|
|
{
|
|
TutorialManager.Instance.ShowTutorial(TutorialManager.TutorialsId.FLOAT_PARAMS_01, 0.5f);
|
|
}
|
|
}
|
|
|
|
public void EquipBait(int baitSlotId)
|
|
{
|
|
EquipmentObject selectedEquipment = GetSelectedEquipment();
|
|
if (selectedEquipment == null)
|
|
{
|
|
UpdateEquipVisibility(false);
|
|
Debug.LogError("EquipItem equipmentObject == null");
|
|
return;
|
|
}
|
|
EquipmentCurrentObject equipmentCurrentObject = equipmentCurrentBaits[baitSlotId - 1];
|
|
if (equipmentCurrentObject.equipmentObject != null)
|
|
{
|
|
equipmentCurrentObject.RemoveObject();
|
|
}
|
|
equipmentCurrentObject.ShowEquipmentChanged(true);
|
|
equipmentCurrentObject.EquipObject(selectedEquipment);
|
|
EquipItem();
|
|
}
|
|
|
|
public void UnequipItem()
|
|
{
|
|
RefreshTotalDurability();
|
|
RefreshMessage();
|
|
RefreshTileViews();
|
|
}
|
|
|
|
public EquipmentObject GetSelectedEquipment()
|
|
{
|
|
if (currentSelectedEquipment != null)
|
|
{
|
|
return currentSelectedEquipment;
|
|
}
|
|
EquipmentTileView equipmentTileView = this.equipmentTileView[tabs.selectedIndex];
|
|
if (equipmentTileView.SelectedIndex < 0)
|
|
{
|
|
return null;
|
|
}
|
|
EquipmentTileViewItem equipmentTileViewItem = equipmentTileView.DataSource[equipmentTileView.SelectedIndex];
|
|
return equipmentTileViewItem.equipmentObject;
|
|
}
|
|
|
|
public void DeselectedEquipment()
|
|
{
|
|
foreach (EquipmentTileView item in equipmentTileView)
|
|
{
|
|
item.SelectedIndex = -1;
|
|
}
|
|
infoBtnShow.gameObject.SetActive(false);
|
|
RefreshInfo();
|
|
}
|
|
|
|
public void ShowHookAndBaits(bool show)
|
|
{
|
|
hookAndBaitsWindow.SetActive(show);
|
|
}
|
|
|
|
public void SetEquipmentType(bool ice)
|
|
{
|
|
if (isIceEquipment == ice)
|
|
{
|
|
return;
|
|
}
|
|
isIceEquipment = ice;
|
|
equipmentNormalParent.SetActive(!isIceEquipment);
|
|
equipmentIceParent.SetActive(isIceEquipment);
|
|
for (int i = 0; i < tabsOnlyNormal.Count; i++)
|
|
{
|
|
tabsOnlyNormal[i].SetActive(!isIceEquipment);
|
|
}
|
|
for (int j = 0; j < tabsOnlyIce.Count; j++)
|
|
{
|
|
tabsOnlyIce[j].SetActive(isIceEquipment);
|
|
}
|
|
for (int k = 0; k < tabsSubCategories.Count; k++)
|
|
{
|
|
tabsSubCategories[k].SetActive(false);
|
|
}
|
|
for (int l = 0; l < tabsCategories.Count; l++)
|
|
{
|
|
tabsCategories[l].Expand(false);
|
|
}
|
|
if (isIceEquipment)
|
|
{
|
|
equipmentTypeButtons[5].ChangeType();
|
|
tabsOnlyNormal[0].transform.parent.GetComponent<VerticalLayoutGroup>().spacing = -100f;
|
|
}
|
|
else
|
|
{
|
|
equipmentTypeButtons[0].ChangeType();
|
|
tabsOnlyNormal[0].transform.parent.GetComponent<VerticalLayoutGroup>().spacing = 0f;
|
|
}
|
|
DeselectedEquipment();
|
|
if (isIceEquipment)
|
|
{
|
|
ShowFloatParams(false);
|
|
}
|
|
else
|
|
{
|
|
CheckFloatArtificialBait();
|
|
if (equipmentManager.GetCurrentEquipment(EquipmentObject.EquipmentType.FLOAT) != null && (bool)equipmentManager.GetCurrentEquipment(EquipmentObject.EquipmentType.FLOAT).prefab)
|
|
{
|
|
ShowFloatParams(true);
|
|
}
|
|
}
|
|
toggleEquipmentButton.GetComponentInChildren<Text>().text = ((!isIceEquipment) ? Utilities.GetTranslation("EQUIPMENT/BTN_SHOW_ICE") : Utilities.GetTranslation("EQUIPMENT/BTN_SHOW_NORMAL"));
|
|
layoutDynamicFix.Refresh();
|
|
}
|
|
|
|
public void ToggleEquipment()
|
|
{
|
|
SetEquipmentType(!isIceEquipment);
|
|
}
|
|
|
|
public void ShowFloatParams(bool show)
|
|
{
|
|
floatDepthWidget.SetActive(show);
|
|
floatWeightWidget.SetActive(show);
|
|
}
|
|
|
|
public void ChangeTab(EquipmentObject equipmentObject)
|
|
{
|
|
EquipmentObject.EquipmentType equipmentType = equipmentObject.equipmentType;
|
|
int subType = 0;
|
|
switch (equipmentType)
|
|
{
|
|
case EquipmentObject.EquipmentType.ROD:
|
|
subType = (int)equipmentObject.prefab.GetComponent<FishingRod>().rodType;
|
|
break;
|
|
case EquipmentObject.EquipmentType.REEL:
|
|
subType = (int)equipmentObject.prefab.GetComponent<FishingReel>().reelType;
|
|
break;
|
|
case EquipmentObject.EquipmentType.LINE:
|
|
subType = (int)equipmentObject.prefab.GetComponent<FishingLine>().lineType;
|
|
break;
|
|
case EquipmentObject.EquipmentType.HOOK:
|
|
subType = (int)equipmentObject.prefab.GetComponent<Bait>().baitType;
|
|
break;
|
|
}
|
|
ChangeTab(equipmentType, subType, false);
|
|
}
|
|
|
|
public void ChangeTab(EquipmentObject.EquipmentType equipmentType, int subType, bool allTypes)
|
|
{
|
|
switch (equipmentType)
|
|
{
|
|
case EquipmentObject.EquipmentType.ROD:
|
|
if (allTypes)
|
|
{
|
|
tabs.SelectTab("GUI/BTN_RODS", true);
|
|
break;
|
|
}
|
|
switch (subType)
|
|
{
|
|
case 0:
|
|
tabs.SelectTab("GUI/BTN_RODS_SPINNING", true);
|
|
break;
|
|
case 1:
|
|
tabs.SelectTab("GUI/BTN_RODS_CASTING", true);
|
|
break;
|
|
case 4:
|
|
tabs.SelectTab("GUI/BTN_RODS_GROUND", true);
|
|
break;
|
|
case 2:
|
|
tabs.SelectTab("GUI/BTN_RODS_FLY", true);
|
|
break;
|
|
default:
|
|
tabs.SelectTab("GUI/BTN_RODS", true);
|
|
break;
|
|
}
|
|
break;
|
|
case EquipmentObject.EquipmentType.ICE_ROD:
|
|
tabs.SelectTab("GUI/BTN_ICE_RODS", true);
|
|
break;
|
|
case EquipmentObject.EquipmentType.REEL:
|
|
if (allTypes)
|
|
{
|
|
tabs.SelectTab("GUI/BTN_REELS", true);
|
|
break;
|
|
}
|
|
switch (subType)
|
|
{
|
|
case 0:
|
|
tabs.SelectTab("GUI/BTN_REELS_STANDARD", true);
|
|
break;
|
|
case 1:
|
|
tabs.SelectTab("GUI/BTN_REELS_LINE_COUNTER", true);
|
|
break;
|
|
case 2:
|
|
tabs.SelectTab("GUI/BTN_REELS_GROUND", true);
|
|
break;
|
|
case 3:
|
|
tabs.SelectTab("GUI/BTN_REELS_FLY", true);
|
|
break;
|
|
default:
|
|
tabs.SelectTab("GUI/BTN_REELS", true);
|
|
break;
|
|
}
|
|
break;
|
|
case EquipmentObject.EquipmentType.LINE:
|
|
tabs.SelectTab("GUI/BTN_LINES", true);
|
|
break;
|
|
case EquipmentObject.EquipmentType.FLOAT:
|
|
tabs.SelectTab("GUI/BTN_FLOATS", true);
|
|
break;
|
|
case EquipmentObject.EquipmentType.HOOK:
|
|
switch (subType)
|
|
{
|
|
case 3:
|
|
tabs.SelectTab("GUI/BTN_WOBBLER", true);
|
|
break;
|
|
case 0:
|
|
tabs.SelectTab("GUI/BTN_HOOKS", true);
|
|
break;
|
|
}
|
|
if (subType == 4)
|
|
{
|
|
tabs.SelectTab("GUI/BTN_SOFT_BAITS", true);
|
|
}
|
|
if (subType == 1)
|
|
{
|
|
tabs.SelectTab("GUI/BTN_SPINNERS", true);
|
|
}
|
|
if (subType == 2)
|
|
{
|
|
tabs.SelectTab("GUI/BTN_SPOONS", true);
|
|
}
|
|
if (subType == 5)
|
|
{
|
|
tabs.SelectTab("GUI/BTN_FLIES", true);
|
|
}
|
|
if (subType == 6)
|
|
{
|
|
tabs.SelectTab("GUI/BTN_SAKURA_DLC_01", true);
|
|
}
|
|
break;
|
|
case EquipmentObject.EquipmentType.BAIT:
|
|
tabs.SelectTab("GUI/BTN_BAITS", true);
|
|
break;
|
|
case EquipmentObject.EquipmentType.OTHER:
|
|
tabs.SelectTab("GUI/BTN_OTHER", true);
|
|
break;
|
|
case EquipmentObject.EquipmentType.BOILIE:
|
|
tabs.SelectTab("GUI/BTN_BOILIES", true);
|
|
break;
|
|
case EquipmentObject.EquipmentType.ROD_STAND:
|
|
tabs.SelectTab("GUI/BTN_ROD_STANDS", true);
|
|
break;
|
|
case EquipmentObject.EquipmentType.FEEDER:
|
|
tabs.SelectTab("GUI/BTN_FEEDERS", true);
|
|
break;
|
|
case EquipmentObject.EquipmentType.FEEDER_BAIT:
|
|
tabs.SelectTab("GUI/BTN_FEEDER_BAITS", true);
|
|
break;
|
|
case EquipmentObject.EquipmentType.BITE_INDICATOR:
|
|
tabs.SelectTab("GUI/BTN_BITE_INDICATORS", true);
|
|
break;
|
|
}
|
|
DeselectedEquipment();
|
|
}
|
|
|
|
public void RefreshTileViews()
|
|
{
|
|
for (int i = 0; i < equipmentTileView.Count; i++)
|
|
{
|
|
equipmentTileView[i].RefreshTileViewComponents();
|
|
}
|
|
}
|
|
|
|
public void ShowOnlyBought(bool onlyBought)
|
|
{
|
|
RefreshList(onlyBought);
|
|
showOnlyBought = onlyBought;
|
|
for (int i = 0; i < equipmentTileView.Count; i++)
|
|
{
|
|
equipmentTileView[i].ShowOnlyBought(onlyBought);
|
|
equipmentTileView[i].enabled = false;
|
|
equipmentTileView[i].enabled = true;
|
|
}
|
|
}
|
|
|
|
public void UpdateEquipmentTypeButton(EquipmentTypeButton currentTypeButton)
|
|
{
|
|
foreach (EquipmentTypeButton equipmentTypeButton in equipmentTypeButtons)
|
|
{
|
|
equipmentTypeButton.activeIndicator.SetActive(false);
|
|
}
|
|
currentTypeButton.activeIndicator.SetActive(true);
|
|
}
|
|
|
|
public void RefreshEquipmentParameters(EquipmentObject equipmentObject)
|
|
{
|
|
if (equipmentObject == null)
|
|
{
|
|
for (int i = 0; i < infoParameters.Count; i++)
|
|
{
|
|
infoParameters[i].gameObject.SetActive(false);
|
|
}
|
|
infoBestFor.text = string.Empty;
|
|
infoBestForLures.text = string.Empty;
|
|
return;
|
|
}
|
|
equipmentObject.Initialize(true);
|
|
for (int j = 0; j < infoParameters.Count; j++)
|
|
{
|
|
if (j >= equipmentObject.parameters.Count)
|
|
{
|
|
continue;
|
|
}
|
|
infoParameters[j].gameObject.SetActive(equipmentObject.parameters[j].isVisible);
|
|
if (equipmentObject.parameters[j].isVisible)
|
|
{
|
|
infoParameters[j].nameText.text = equipmentObject.parameters[j].parameterName;
|
|
if (equipmentObject.parameters[j].type == EquipmentObject.Parameter.ParameterType.STRING)
|
|
{
|
|
infoParameters[j].valueText.text = Utilities.GetTranslation(equipmentObject.parameters[j].parameterString);
|
|
}
|
|
else if (equipmentObject.parameters[j].type == EquipmentObject.Parameter.ParameterType.INT)
|
|
{
|
|
infoParameters[j].valueText.text = equipmentObject.parameters[j].parameterInt.ToString();
|
|
}
|
|
else if (equipmentObject.parameters[j].type == EquipmentObject.Parameter.ParameterType.FLOAT)
|
|
{
|
|
infoParameters[j].valueText.text = equipmentObject.parameters[j].parameterFloat.ToString("F2");
|
|
}
|
|
else if (equipmentObject.parameters[j].type == EquipmentObject.Parameter.ParameterType.BOOL)
|
|
{
|
|
infoParameters[j].valueText.text = equipmentObject.parameters[j].parameterBool.ToString();
|
|
}
|
|
}
|
|
}
|
|
if (equipmentObject.equipmentType == EquipmentObject.EquipmentType.BAIT || equipmentObject.equipmentType == EquipmentObject.EquipmentType.BOILIE || equipmentObject.equipmentType == EquipmentObject.EquipmentType.FEEDER_BAIT || (equipmentObject.equipmentType == EquipmentObject.EquipmentType.HOOK && equipmentObject.prefab.GetComponent<Bait>().baitType != Bait.BaitType.HOOK))
|
|
{
|
|
infoBestFor.text = "<b>" + Utilities.GetTranslation("GUI/BEST_FOR") + "</b>: ";
|
|
FishLikesParams component = equipmentObject.prefab.GetComponent<FishLikesParams>();
|
|
foreach (FishLikesParams.FishInterest fishInterest in component.fishInterests)
|
|
{
|
|
FishManager.FishDefinition fishDefinition = GlobalSettings.Instance.fishManager.GetFishDefinition(fishInterest.species);
|
|
if (fishInterest.interest >= 0.5f && fishDefinition != null && fishDefinition.isAvailable && fishDefinition.isAvailableFromDLCs)
|
|
{
|
|
infoBestFor.text += GlobalSettings.Instance.fishManager.GetFishName(fishInterest.species);
|
|
infoBestFor.text += ", ";
|
|
}
|
|
}
|
|
infoBestFor.text = infoBestFor.text.Remove(infoBestFor.text.Length - 2, 2);
|
|
infoBestForLures.text = infoBestFor.text;
|
|
infoBestFor.enabled = equipmentObject.equipmentType != EquipmentObject.EquipmentType.HOOK;
|
|
infoBestForLures.enabled = equipmentObject.equipmentType == EquipmentObject.EquipmentType.HOOK;
|
|
}
|
|
else
|
|
{
|
|
infoBestFor.text = string.Empty;
|
|
infoBestForLures.text = string.Empty;
|
|
}
|
|
if (equipmentObject.equipmentType == EquipmentObject.EquipmentType.HOOK)
|
|
{
|
|
infoBestFor.text = string.Empty;
|
|
}
|
|
else
|
|
{
|
|
infoBestForLures.text = string.Empty;
|
|
}
|
|
infoBestForScrollRect.content.sizeDelta = new Vector2(infoBestFor.preferredWidth, infoBestFor.preferredHeight);
|
|
infoBestForScrollRect.verticalScrollbar.value = 1f;
|
|
infoBestForScrollRect.verticalNormalizedPosition = 1f;
|
|
infoBestForLuresScrollRect.content.sizeDelta = new Vector2(infoBestForLures.preferredWidth, infoBestForLures.preferredHeight);
|
|
infoBestForLuresScrollRect.verticalScrollbar.value = 1f;
|
|
infoBestForLuresScrollRect.verticalNormalizedPosition = 1f;
|
|
infoBestForScrollRect.gameObject.SetActive(infoBestFor.text != string.Empty);
|
|
infoBestForLuresScrollRect.gameObject.SetActive(infoBestForLures.text != string.Empty);
|
|
}
|
|
|
|
public void RefreshTotalDurability()
|
|
{
|
|
}
|
|
|
|
public void ChangeEquipment()
|
|
{
|
|
if ((bool)GameController.Instance)
|
|
{
|
|
GameController.Instance.fishingPlayer.currentHands.ChangeEquipmentButton();
|
|
ResetChanged();
|
|
}
|
|
}
|
|
|
|
public void ResetChanged()
|
|
{
|
|
for (int i = 0; i < equipmentCurrentObjects.Count; i++)
|
|
{
|
|
equipmentCurrentObjects[i].ShowEquipmentChanged(false);
|
|
}
|
|
for (int j = 0; j < equipmentCurrentBaits.Count; j++)
|
|
{
|
|
equipmentCurrentBaits[j].ShowEquipmentChanged(false);
|
|
}
|
|
}
|
|
|
|
public bool IsEquipmentWithAmount(EquipmentObject.EquipmentType equipmentType)
|
|
{
|
|
return equipmentType == EquipmentObject.EquipmentType.HOOK || equipmentType == EquipmentObject.EquipmentType.BOILIE || equipmentType == EquipmentObject.EquipmentType.ROD || equipmentType == EquipmentObject.EquipmentType.ICE_ROD || equipmentType == EquipmentObject.EquipmentType.REEL || equipmentType == EquipmentObject.EquipmentType.LINE || equipmentType == EquipmentObject.EquipmentType.FEEDER || equipmentType == EquipmentObject.EquipmentType.FEEDER_BAIT || equipmentType == EquipmentObject.EquipmentType.FLOAT || equipmentType == EquipmentObject.EquipmentType.BITE_INDICATOR;
|
|
}
|
|
|
|
public bool IsEquippedInCurrentSet(EquipmentObject equipmentObject)
|
|
{
|
|
if (equipmentObject.IsBuyAndEquip())
|
|
{
|
|
return equipmentObject.isEquipped;
|
|
}
|
|
return equipmentCurrentObjects[(int)equipmentObject.equipmentType].equipmentObject == equipmentObject;
|
|
}
|
|
|
|
public void UpdateCanEquipmentBeChanged()
|
|
{
|
|
canEquipmentBeChanged = true;
|
|
if ((bool)GameController.Instance)
|
|
{
|
|
FishingHands fishingHands = GameController.Instance.fishingPlayer.allFishingHands[equipmentManager.currentEquipmentSetId];
|
|
if (GameController.Instance.iceLevel)
|
|
{
|
|
isCurrentSet = equipmentManager.currentEquipmentSetId == GameController.Instance.fishingPlayer.currentHands.equipmentSetId;
|
|
}
|
|
else
|
|
{
|
|
isCurrentSet = GameController.Instance.fishingPlayer.currentHands == fishingHands;
|
|
}
|
|
canSetBeChanged = GameController.Instance.fishingPlayer.CanChangeEquipment() || ((bool)GameController.Instance.fishingPlayer.currentHands.fishingRod && GameController.Instance.fishingPlayer.currentHands.fishingRod.isOnRodStand);
|
|
Utilities.LogError(GameController.Instance.iceLevel, "equipmentManager.currentEquipmentSetId: " + equipmentManager.currentEquipmentSetId + " isCurrentSet: " + isCurrentSet + " canSetBeChanged: " + canSetBeChanged, "lightblue", true);
|
|
if (!isCurrentSet)
|
|
{
|
|
canEquipmentBeChanged = !fishingHands.fishingRod || !fishingHands.fishingRod.isOnRodStand;
|
|
}
|
|
else
|
|
{
|
|
canEquipmentBeChanged = GameController.Instance.fishingPlayer.CanChangeEquipment();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void UpdateEquipVisibility(bool showEquipBtn)
|
|
{
|
|
infoBtnEquip.interactable = showEquipBtn;
|
|
for (int i = 0; i < infoBtnEquipBaits.Count; i++)
|
|
{
|
|
infoBtnEquipBaits[i].interactable = showEquipBtn;
|
|
}
|
|
}
|
|
}
|