1316 lines
36 KiB
C#
1316 lines
36 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using BitStrap;
|
|
using UnityEngine;
|
|
|
|
public class EquipmentManager : MonoBehaviour
|
|
{
|
|
[Serializable]
|
|
public class SetSpecificParameters
|
|
{
|
|
public float currentFloatDepth = 50f;
|
|
|
|
public float currentFloatWeight;
|
|
|
|
public float currentHookSize;
|
|
}
|
|
|
|
[ReadOnly]
|
|
public int equipmentCount;
|
|
|
|
public List<EquipmentObject> equipmentAll = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentRods = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentIceRods = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentReels = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentLines = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentFloats = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentBaits = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentHooks = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentNets = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentOther = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentBoilies = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentRodStands = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentFeeders = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentFeederBaits = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentBiteIndicator = new List<EquipmentObject>();
|
|
|
|
[Header("Rods")]
|
|
public List<EquipmentObject> equipmentRodsSpinning = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentRodsCasting = new List<EquipmentObject>();
|
|
|
|
[Header("Reels")]
|
|
public List<EquipmentObject> equipmentReelsStandard = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentReelsLineCounter = new List<EquipmentObject>();
|
|
|
|
[Header("Ground")]
|
|
public List<EquipmentObject> equipmentRodsGround = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentReelsGround = new List<EquipmentObject>();
|
|
|
|
[Header("Fly")]
|
|
public List<EquipmentObject> equipmentRodsFly = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentReelsFly = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentLinesFly = new List<EquipmentObject>();
|
|
|
|
[Header("Hooks/Lures")]
|
|
public List<EquipmentObject> equipmentNormalHooks = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentSpinners = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentSpoons = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentWobblers = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentSoftBaits = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentFlies = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentDLC_01 = new List<EquipmentObject>();
|
|
|
|
[Header("Current")]
|
|
public List<EquipmentObject> currentEquipment = new List<EquipmentObject>(13);
|
|
|
|
public List<EquipmentObject> currentBaits = new List<EquipmentObject>();
|
|
|
|
public const int equipmentSetsAmount = 5;
|
|
|
|
public int currentEquipmentSetId;
|
|
|
|
public List<EquipmentObject>[] equipmentSets = new List<EquipmentObject>[5];
|
|
|
|
public List<EquipmentObject>[] baitsSets = new List<EquipmentObject>[5];
|
|
|
|
public List<EquipmentObject> equipmentSet_01 = new List<EquipmentObject>(13);
|
|
|
|
public List<EquipmentObject> baitsSet_01 = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentSet_02 = new List<EquipmentObject>(13);
|
|
|
|
public List<EquipmentObject> baitsSet_02 = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentSet_03 = new List<EquipmentObject>(13);
|
|
|
|
public List<EquipmentObject> baitsSet_03 = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentSet_04 = new List<EquipmentObject>(13);
|
|
|
|
public List<EquipmentObject> baitsSet_04 = new List<EquipmentObject>();
|
|
|
|
public List<EquipmentObject> equipmentSet_05 = new List<EquipmentObject>(13);
|
|
|
|
public List<EquipmentObject> baitsSet_05 = new List<EquipmentObject>();
|
|
|
|
[Space(10f)]
|
|
public List<string> startEquipment = new List<string>();
|
|
|
|
[Header("Random params set")]
|
|
public List<FishingRod> equipmentFishingRods = new List<FishingRod>();
|
|
|
|
public List<FishingReel> equipmentFishingReels = new List<FishingReel>();
|
|
|
|
public float minFloatDepth = 30f;
|
|
|
|
public float maxFloatDepth = 250f;
|
|
|
|
[Space(10f)]
|
|
public SetSpecificParameters currentSetSpecificParameters;
|
|
|
|
public List<SetSpecificParameters> setSpecificParameters = new List<SetSpecificParameters>();
|
|
|
|
public float currentFloatDepth;
|
|
|
|
public float currentFloatWeight;
|
|
|
|
public float currentHookSize;
|
|
|
|
[Space(10f)]
|
|
public List<float> hookSizesCm = new List<float>();
|
|
|
|
public float sellObjectFactor = 0.66f;
|
|
|
|
[Header("Equipment Change")]
|
|
public List<bool> equipmentChanged = new List<bool>(13);
|
|
|
|
[Header("Producer Names")]
|
|
public List<string> producerNames = new List<string>();
|
|
|
|
[Header("Prices")]
|
|
public float globalPriceMultiplier = 1f;
|
|
|
|
public Vector2 priceRod = Vector2.one;
|
|
|
|
public Vector2 priceIceRod = Vector2.one;
|
|
|
|
public Vector2 priceReel = Vector2.one;
|
|
|
|
public Vector2 priceLine = Vector2.one;
|
|
|
|
public Vector2 priceFloat = Vector2.one;
|
|
|
|
public Vector2 priceBait = Vector2.one;
|
|
|
|
public Vector2 priceHook = Vector2.one;
|
|
|
|
[HideInInspector]
|
|
public PlayerSettingsMy playerSettings;
|
|
|
|
private void Awake()
|
|
{
|
|
equipmentSets[0] = equipmentSet_01;
|
|
equipmentSets[1] = equipmentSet_02;
|
|
equipmentSets[2] = equipmentSet_03;
|
|
equipmentSets[3] = equipmentSet_04;
|
|
equipmentSets[4] = equipmentSet_05;
|
|
baitsSets[0] = baitsSet_01;
|
|
baitsSets[1] = baitsSet_02;
|
|
baitsSets[2] = baitsSet_03;
|
|
baitsSets[3] = baitsSet_04;
|
|
baitsSets[4] = baitsSet_05;
|
|
ChangeCurrentEquipmentSet(0);
|
|
foreach (EquipmentObject item in equipmentRodsSpinning)
|
|
{
|
|
equipmentRods.Add(item);
|
|
}
|
|
foreach (EquipmentObject item2 in equipmentRodsCasting)
|
|
{
|
|
equipmentRods.Add(item2);
|
|
}
|
|
foreach (EquipmentObject item3 in equipmentReelsStandard)
|
|
{
|
|
equipmentReels.Add(item3);
|
|
}
|
|
foreach (EquipmentObject item4 in equipmentReelsLineCounter)
|
|
{
|
|
equipmentReels.Add(item4);
|
|
}
|
|
foreach (EquipmentObject item5 in equipmentRodsGround)
|
|
{
|
|
equipmentRods.Add(item5);
|
|
}
|
|
foreach (EquipmentObject item6 in equipmentReelsGround)
|
|
{
|
|
equipmentReels.Add(item6);
|
|
}
|
|
foreach (EquipmentObject item7 in equipmentRodsFly)
|
|
{
|
|
equipmentRods.Add(item7);
|
|
}
|
|
foreach (EquipmentObject item8 in equipmentReelsFly)
|
|
{
|
|
equipmentReels.Add(item8);
|
|
}
|
|
foreach (EquipmentObject item9 in equipmentLinesFly)
|
|
{
|
|
equipmentLines.Add(item9);
|
|
}
|
|
foreach (EquipmentObject item10 in equipmentDLC_01)
|
|
{
|
|
if (item10.equipmentType != EquipmentObject.EquipmentType.HOOK)
|
|
{
|
|
continue;
|
|
}
|
|
if ((bool)DLCManager.Instance && DLCManager.Instance.IsDLCInstalled(DLCManager.DLC_ID.EQUIPMENT_01))
|
|
{
|
|
switch (item10.prefab.GetComponent<Bait>().baitType)
|
|
{
|
|
case Bait.BaitType.WOBBLER:
|
|
equipmentWobblers.Add(item10);
|
|
break;
|
|
case Bait.BaitType.SOFT_BAIT:
|
|
equipmentSoftBaits.Add(item10);
|
|
break;
|
|
case Bait.BaitType.SPINNER:
|
|
equipmentSpinners.Add(item10);
|
|
break;
|
|
case Bait.BaitType.SPOON:
|
|
equipmentSpoons.Add(item10);
|
|
break;
|
|
case Bait.BaitType.FLY:
|
|
equipmentFlies.Add(item10);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
equipmentHooks.Add(item10);
|
|
}
|
|
}
|
|
foreach (EquipmentObject equipmentNormalHook in equipmentNormalHooks)
|
|
{
|
|
equipmentHooks.Add(equipmentNormalHook);
|
|
}
|
|
foreach (EquipmentObject equipmentWobbler in equipmentWobblers)
|
|
{
|
|
equipmentHooks.Add(equipmentWobbler);
|
|
}
|
|
foreach (EquipmentObject equipmentSoftBait in equipmentSoftBaits)
|
|
{
|
|
equipmentHooks.Add(equipmentSoftBait);
|
|
}
|
|
foreach (EquipmentObject equipmentSpinner in equipmentSpinners)
|
|
{
|
|
equipmentHooks.Add(equipmentSpinner);
|
|
}
|
|
foreach (EquipmentObject equipmentSpoon in equipmentSpoons)
|
|
{
|
|
equipmentHooks.Add(equipmentSpoon);
|
|
}
|
|
foreach (EquipmentObject equipmentFly in equipmentFlies)
|
|
{
|
|
equipmentHooks.Add(equipmentFly);
|
|
}
|
|
}
|
|
|
|
private void Start()
|
|
{
|
|
playerSettings = GlobalSettings.Instance.playerSettings;
|
|
foreach (EquipmentObject equipmentRod in equipmentRods)
|
|
{
|
|
equipmentRod.equipmentType = EquipmentObject.EquipmentType.ROD;
|
|
equipmentRod.hasAmount = true;
|
|
equipmentRod.maxAmount = 5;
|
|
equipmentRod.Initialize();
|
|
}
|
|
foreach (EquipmentObject equipmentIceRod in equipmentIceRods)
|
|
{
|
|
equipmentIceRod.equipmentType = EquipmentObject.EquipmentType.ICE_ROD;
|
|
equipmentIceRod.hasAmount = true;
|
|
equipmentIceRod.maxAmount = 5;
|
|
equipmentIceRod.Initialize();
|
|
}
|
|
foreach (EquipmentObject equipmentReel in equipmentReels)
|
|
{
|
|
equipmentReel.equipmentType = EquipmentObject.EquipmentType.REEL;
|
|
equipmentReel.hasAmount = true;
|
|
equipmentReel.maxAmount = 5;
|
|
equipmentReel.Initialize();
|
|
}
|
|
foreach (EquipmentObject equipmentLine in equipmentLines)
|
|
{
|
|
equipmentLine.equipmentType = EquipmentObject.EquipmentType.LINE;
|
|
equipmentLine.hasAmount = true;
|
|
equipmentLine.maxAmount = 5;
|
|
equipmentLine.Initialize();
|
|
}
|
|
foreach (EquipmentObject equipmentFloat in equipmentFloats)
|
|
{
|
|
equipmentFloat.equipmentType = EquipmentObject.EquipmentType.FLOAT;
|
|
equipmentFloat.hasAmount = true;
|
|
equipmentFloat.maxAmount = 5;
|
|
equipmentFloat.Initialize();
|
|
}
|
|
foreach (EquipmentObject equipmentBait in equipmentBaits)
|
|
{
|
|
equipmentBait.equipmentType = EquipmentObject.EquipmentType.BAIT;
|
|
equipmentBait.Initialize();
|
|
}
|
|
foreach (EquipmentObject equipmentHook in equipmentHooks)
|
|
{
|
|
equipmentHook.equipmentType = EquipmentObject.EquipmentType.HOOK;
|
|
equipmentHook.Initialize();
|
|
}
|
|
foreach (EquipmentObject item in equipmentOther)
|
|
{
|
|
item.equipmentType = EquipmentObject.EquipmentType.OTHER;
|
|
item.Initialize();
|
|
}
|
|
foreach (EquipmentObject equipmentBoily in equipmentBoilies)
|
|
{
|
|
equipmentBoily.equipmentType = EquipmentObject.EquipmentType.BOILIE;
|
|
equipmentBoily.Initialize();
|
|
}
|
|
foreach (EquipmentObject equipmentRodStand in equipmentRodStands)
|
|
{
|
|
equipmentRodStand.equipmentType = EquipmentObject.EquipmentType.ROD_STAND;
|
|
equipmentRodStand.Initialize();
|
|
}
|
|
foreach (EquipmentObject equipmentFeeder in equipmentFeeders)
|
|
{
|
|
equipmentFeeder.equipmentType = EquipmentObject.EquipmentType.FEEDER;
|
|
equipmentFeeder.Initialize();
|
|
}
|
|
foreach (EquipmentObject equipmentFeederBait in equipmentFeederBaits)
|
|
{
|
|
equipmentFeederBait.price = Mathf.RoundToInt((float)equipmentFeederBait.price * 0.66f);
|
|
equipmentFeederBait.equipmentType = EquipmentObject.EquipmentType.FEEDER_BAIT;
|
|
equipmentFeederBait.Initialize();
|
|
}
|
|
foreach (EquipmentObject item2 in equipmentBiteIndicator)
|
|
{
|
|
item2.equipmentType = EquipmentObject.EquipmentType.BITE_INDICATOR;
|
|
item2.Initialize();
|
|
}
|
|
UpdateAllPriceAndLevel();
|
|
}
|
|
|
|
public List<EquipmentObject> GetEquipmentList(EquipmentObject.EquipmentType type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case EquipmentObject.EquipmentType.ROD:
|
|
return equipmentRods;
|
|
case EquipmentObject.EquipmentType.ICE_ROD:
|
|
return equipmentIceRods;
|
|
case EquipmentObject.EquipmentType.REEL:
|
|
return equipmentReels;
|
|
case EquipmentObject.EquipmentType.LINE:
|
|
return equipmentLines;
|
|
case EquipmentObject.EquipmentType.FLOAT:
|
|
return equipmentFloats;
|
|
case EquipmentObject.EquipmentType.BAIT:
|
|
return equipmentBaits;
|
|
case EquipmentObject.EquipmentType.HOOK:
|
|
return equipmentHooks;
|
|
case EquipmentObject.EquipmentType.OTHER:
|
|
return equipmentOther;
|
|
case EquipmentObject.EquipmentType.BOILIE:
|
|
return equipmentBoilies;
|
|
case EquipmentObject.EquipmentType.ROD_STAND:
|
|
return equipmentRodStands;
|
|
case EquipmentObject.EquipmentType.FEEDER:
|
|
return equipmentFeeders;
|
|
case EquipmentObject.EquipmentType.FEEDER_BAIT:
|
|
return equipmentFeederBaits;
|
|
case EquipmentObject.EquipmentType.BITE_INDICATOR:
|
|
return equipmentBiteIndicator;
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public List<EquipmentObject> GetEquipmentSpecificList(EquipmentTileViewParameters equipmentTileViewParameters)
|
|
{
|
|
return GetEquipmentSpecificList(equipmentTileViewParameters.equipmentType, equipmentTileViewParameters.rodType, equipmentTileViewParameters.reelType, equipmentTileViewParameters.lineType, equipmentTileViewParameters.baitType, equipmentTileViewParameters.allTypes);
|
|
}
|
|
|
|
public List<EquipmentObject> GetEquipmentSpecificList(EquipmentObject.EquipmentType type, FishingRod.RodType rodType, FishingReel.ReelType reelType, FishingLine.LineType lineType, Bait.BaitType baitType, bool allTypes)
|
|
{
|
|
switch (type)
|
|
{
|
|
case EquipmentObject.EquipmentType.ROD:
|
|
if (allTypes)
|
|
{
|
|
return GetEquipmentList(type);
|
|
}
|
|
switch (rodType)
|
|
{
|
|
case FishingRod.RodType.SPINNING:
|
|
return equipmentRodsSpinning;
|
|
case FishingRod.RodType.CASTING:
|
|
return equipmentRodsCasting;
|
|
case FishingRod.RodType.GROUND:
|
|
return equipmentRodsGround;
|
|
case FishingRod.RodType.FLY_FISHING:
|
|
return equipmentRodsFly;
|
|
}
|
|
break;
|
|
case EquipmentObject.EquipmentType.REEL:
|
|
if (allTypes)
|
|
{
|
|
return GetEquipmentList(type);
|
|
}
|
|
switch (reelType)
|
|
{
|
|
case FishingReel.ReelType.STANDARD:
|
|
return equipmentReelsStandard;
|
|
case FishingReel.ReelType.LINE_COUNTER:
|
|
return equipmentReelsLineCounter;
|
|
case FishingReel.ReelType.GROUND:
|
|
return equipmentReelsGround;
|
|
case FishingReel.ReelType.FLY:
|
|
return equipmentReelsFly;
|
|
}
|
|
break;
|
|
case EquipmentObject.EquipmentType.LINE:
|
|
return GetEquipmentList(type);
|
|
case EquipmentObject.EquipmentType.HOOK:
|
|
switch (baitType)
|
|
{
|
|
case Bait.BaitType.HOOK:
|
|
return equipmentNormalHooks;
|
|
case Bait.BaitType.WOBBLER:
|
|
return equipmentWobblers;
|
|
case Bait.BaitType.SOFT_BAIT:
|
|
return equipmentSoftBaits;
|
|
case Bait.BaitType.SPINNER:
|
|
return equipmentSpinners;
|
|
case Bait.BaitType.SPOON:
|
|
return equipmentSpoons;
|
|
case Bait.BaitType.FLY:
|
|
return equipmentFlies;
|
|
case Bait.BaitType.SAKURA_DLC_01:
|
|
return equipmentDLC_01;
|
|
}
|
|
break;
|
|
default:
|
|
return GetEquipmentList(type);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public List<EquipmentObject> GetHooksList(Bait.BaitType type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case Bait.BaitType.HOOK:
|
|
return equipmentNormalHooks;
|
|
case Bait.BaitType.WOBBLER:
|
|
return equipmentWobblers;
|
|
case Bait.BaitType.SOFT_BAIT:
|
|
return equipmentSoftBaits;
|
|
case Bait.BaitType.SPINNER:
|
|
return equipmentSpinners;
|
|
case Bait.BaitType.SPOON:
|
|
return equipmentSpoons;
|
|
case Bait.BaitType.FLY:
|
|
return equipmentFlies;
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public EquipmentObject FindEquipment(EquipmentObject.EquipmentType type, string id)
|
|
{
|
|
if (string.IsNullOrEmpty(id))
|
|
{
|
|
return null;
|
|
}
|
|
List<EquipmentObject> equipmentList = GetEquipmentList(type);
|
|
if (equipmentList != null)
|
|
{
|
|
foreach (EquipmentObject item in equipmentList)
|
|
{
|
|
if (item.id == id)
|
|
{
|
|
return item;
|
|
}
|
|
}
|
|
}
|
|
Debug.LogError("FindEquipment not found: " + id);
|
|
return null;
|
|
}
|
|
|
|
public EquipmentObject FindEquipment(EquipmentObject.EquipmentSubType type, string id)
|
|
{
|
|
if (string.IsNullOrEmpty(id))
|
|
{
|
|
return null;
|
|
}
|
|
foreach (EquipmentObject item in equipmentOther)
|
|
{
|
|
if (item.id == id)
|
|
{
|
|
return item;
|
|
}
|
|
}
|
|
Debug.LogError("FindEquipment SubType not found: " + id);
|
|
return null;
|
|
}
|
|
|
|
public void EquipObject(EquipmentObject equipmentObject, int setId = -1, int baitId = -1)
|
|
{
|
|
if (equipmentObject.equipmentType == EquipmentObject.EquipmentType.BAIT)
|
|
{
|
|
List<EquipmentObject> list = ((setId != -1) ? baitsSets[setId] : currentBaits);
|
|
int num = ((baitId != -1) ? baitId : GetAvailableBaitSlot());
|
|
if (num < 0 || num >= list.Count)
|
|
{
|
|
Debug.LogWarning("No slot ID");
|
|
return;
|
|
}
|
|
if (list[num] != null)
|
|
{
|
|
}
|
|
list[num] = equipmentObject;
|
|
}
|
|
else if (equipmentObject.equipmentType == EquipmentObject.EquipmentType.ROD_STAND || equipmentObject.equipmentType == EquipmentObject.EquipmentType.BOILIE)
|
|
{
|
|
for (int i = 0; i < equipmentSets.Length; i++)
|
|
{
|
|
if (equipmentSets[i][(int)equipmentObject.equipmentType] != null)
|
|
{
|
|
equipmentSets[i][(int)equipmentObject.equipmentType].Equip(false);
|
|
}
|
|
equipmentSets[i][(int)equipmentObject.equipmentType] = equipmentObject;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
List<EquipmentObject> list2 = ((setId != -1) ? equipmentSets[setId] : currentEquipment);
|
|
if (list2[(int)equipmentObject.equipmentType] != null)
|
|
{
|
|
list2[(int)equipmentObject.equipmentType].Equip(false);
|
|
}
|
|
list2[(int)equipmentObject.equipmentType] = equipmentObject;
|
|
}
|
|
equipmentObject.Equip(true);
|
|
}
|
|
|
|
public void UnequipObject(EquipmentObject.EquipmentType equipmentType, int setId = -1, int baitId = 0)
|
|
{
|
|
switch (equipmentType)
|
|
{
|
|
case EquipmentObject.EquipmentType.BAIT:
|
|
{
|
|
List<EquipmentObject> list2 = ((setId != -1) ? baitsSets[setId] : currentBaits);
|
|
if (list2[baitId] != null && list2[baitId].prefab != null)
|
|
{
|
|
list2[baitId].Equip(false);
|
|
}
|
|
list2[baitId] = null;
|
|
break;
|
|
}
|
|
case EquipmentObject.EquipmentType.BOILIE:
|
|
case EquipmentObject.EquipmentType.ROD_STAND:
|
|
{
|
|
for (int i = 0; i < equipmentSets.Length; i++)
|
|
{
|
|
if (equipmentSets[i][(int)equipmentType] != null)
|
|
{
|
|
equipmentSets[i][(int)equipmentType].Equip(false);
|
|
}
|
|
equipmentSets[i][(int)equipmentType] = null;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
List<EquipmentObject> list = ((setId != -1) ? equipmentSets[setId] : currentEquipment);
|
|
if (list[(int)equipmentType] != null)
|
|
{
|
|
list[(int)equipmentType].Equip(false);
|
|
}
|
|
list[(int)equipmentType] = null;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public int GetAvailableBaitSlot()
|
|
{
|
|
for (int i = 0; i < currentBaits.Count; i++)
|
|
{
|
|
if (currentBaits[i] == null || currentBaits[i].prefab == null)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public bool HasAvailableBaitSlot()
|
|
{
|
|
return GetAvailableBaitSlot() >= 0;
|
|
}
|
|
|
|
public bool HasBoilieEquiped()
|
|
{
|
|
return GetCurrentEquipment(EquipmentObject.EquipmentType.BOILIE) != null && (bool)GetCurrentEquipment(EquipmentObject.EquipmentType.BOILIE).prefab;
|
|
}
|
|
|
|
public void BuyObject(EquipmentObject equipmentObject)
|
|
{
|
|
playerSettings.AddMoney(-equipmentObject.GetCurrentSellPrice());
|
|
equipmentObject.Buy();
|
|
Save();
|
|
playerSettings.Save();
|
|
}
|
|
|
|
public void SellObject(EquipmentObject equipmentObject)
|
|
{
|
|
playerSettings.AddMoney(Mathf.RoundToInt((float)equipmentObject.price * sellObjectFactor));
|
|
equipmentObject.Sell();
|
|
Save();
|
|
playerSettings.Save();
|
|
}
|
|
|
|
public EquipmentObject GetCurrentEquipment(EquipmentObject.EquipmentType equipmentType)
|
|
{
|
|
if (currentEquipment == null)
|
|
{
|
|
Debug.LogError("currentEquipment == null");
|
|
return null;
|
|
}
|
|
return currentEquipment[(int)equipmentType];
|
|
}
|
|
|
|
public List<EquipmentObject> GetCurrentEquipmentBaits()
|
|
{
|
|
return currentBaits;
|
|
}
|
|
|
|
public void ChangeCurrentEquipmentSet(int setId)
|
|
{
|
|
currentEquipmentSetId = setId;
|
|
currentEquipment = equipmentSets[setId];
|
|
currentBaits = baitsSets[setId];
|
|
currentSetSpecificParameters = setSpecificParameters[setId];
|
|
}
|
|
|
|
public int CountFillets(int fishMoney)
|
|
{
|
|
return Mathf.CeilToInt((float)fishMoney / ((float)FindEquipment(EquipmentObject.EquipmentType.OTHER, "FILLET_01").price * 1.3f));
|
|
}
|
|
|
|
public void AddFillets(int fishMoney)
|
|
{
|
|
EquipmentObject equipmentObject = FindEquipment(EquipmentObject.EquipmentType.OTHER, "FILLET_01");
|
|
int num = Mathf.CeilToInt((float)fishMoney / ((float)equipmentObject.price * 1.3f));
|
|
equipmentObject.amount += Mathf.CeilToInt(num);
|
|
Debug.Log("Added fillets: " + num + " fishMoney: " + fishMoney);
|
|
}
|
|
|
|
public void AddYoungFishBait(int size, int amount)
|
|
{
|
|
EquipmentObject equipmentObject = null;
|
|
switch (size)
|
|
{
|
|
case 1:
|
|
equipmentObject = FindEquipment(EquipmentObject.EquipmentType.BAIT, "BAIT_YOUNG_FISH_S_01");
|
|
break;
|
|
case 2:
|
|
equipmentObject = FindEquipment(EquipmentObject.EquipmentType.BAIT, "BAIT_YOUNG_FISH_M_01");
|
|
break;
|
|
case 3:
|
|
equipmentObject = FindEquipment(EquipmentObject.EquipmentType.BAIT, "BAIT_YOUNG_FISH_L_01");
|
|
break;
|
|
}
|
|
if (equipmentObject != null)
|
|
{
|
|
equipmentObject.amount += amount;
|
|
}
|
|
Debug.Log("AddYoungFishBait size:" + size);
|
|
}
|
|
|
|
public int GetRodId()
|
|
{
|
|
if ((bool)GetCurrentEquipment(EquipmentObject.EquipmentType.ROD).prefab)
|
|
{
|
|
for (int i = 0; i < equipmentRods.Count; i++)
|
|
{
|
|
if (equipmentRods[i].prefab == GetCurrentEquipment(EquipmentObject.EquipmentType.ROD).prefab)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
[Button]
|
|
public void BuyAll()
|
|
{
|
|
for (int i = 0; i < 13; i++)
|
|
{
|
|
List<EquipmentObject> equipmentList = GetEquipmentList((EquipmentObject.EquipmentType)i);
|
|
if (equipmentList != null)
|
|
{
|
|
for (int j = 0; j < equipmentList.Count; j++)
|
|
{
|
|
equipmentList[j].Buy();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Button]
|
|
public void BuyAllMax()
|
|
{
|
|
for (int i = 0; i < 13; i++)
|
|
{
|
|
List<EquipmentObject> equipmentList = GetEquipmentList((EquipmentObject.EquipmentType)i);
|
|
if (equipmentList != null)
|
|
{
|
|
for (int j = 0; j < equipmentList.Count; j++)
|
|
{
|
|
equipmentList[j].SetAmount(equipmentList[j].maxAmount);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool HasAnythingChanged()
|
|
{
|
|
for (int i = 0; i < equipmentChanged.Count; i++)
|
|
{
|
|
if (equipmentChanged[i])
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void ResetChanged()
|
|
{
|
|
for (int i = 0; i < equipmentChanged.Count; i++)
|
|
{
|
|
equipmentChanged[i] = false;
|
|
}
|
|
}
|
|
|
|
public void EquipmentChanged(EquipmentObject.EquipmentType equipmentType)
|
|
{
|
|
if (equipmentType == EquipmentObject.EquipmentType.COUNT)
|
|
{
|
|
equipmentChanged[0] = GameController.Instance;
|
|
equipmentChanged[10] = GameController.Instance;
|
|
equipmentChanged[12] = GameController.Instance;
|
|
}
|
|
else
|
|
{
|
|
equipmentChanged[(int)equipmentType] = GameController.Instance;
|
|
}
|
|
}
|
|
|
|
public string GetProducerName(int id)
|
|
{
|
|
if (id >= 0)
|
|
{
|
|
return producerNames[id];
|
|
}
|
|
return string.Empty;
|
|
}
|
|
|
|
public float CalculateEquipmentDurability()
|
|
{
|
|
return 0f;
|
|
}
|
|
|
|
[Button]
|
|
public void UpdateAllPriceAndLevel()
|
|
{
|
|
foreach (EquipmentObject equipmentRod in equipmentRods)
|
|
{
|
|
equipmentRod.CalculateValue();
|
|
}
|
|
foreach (EquipmentObject equipmentIceRod in equipmentIceRods)
|
|
{
|
|
equipmentIceRod.CalculateValue();
|
|
}
|
|
foreach (EquipmentObject equipmentReel in equipmentReels)
|
|
{
|
|
equipmentReel.CalculateValue();
|
|
}
|
|
foreach (EquipmentObject equipmentLine in equipmentLines)
|
|
{
|
|
equipmentLine.CalculateValue();
|
|
}
|
|
foreach (EquipmentObject equipmentFloat in equipmentFloats)
|
|
{
|
|
equipmentFloat.CalculateValue();
|
|
}
|
|
foreach (EquipmentObject equipmentBait in equipmentBaits)
|
|
{
|
|
equipmentBait.CalculateValue();
|
|
}
|
|
foreach (EquipmentObject equipmentHook in equipmentHooks)
|
|
{
|
|
equipmentHook.CalculateValue();
|
|
}
|
|
foreach (EquipmentObject item in equipmentOther)
|
|
{
|
|
item.CalculateValue();
|
|
}
|
|
foreach (EquipmentObject equipmentBoily in equipmentBoilies)
|
|
{
|
|
equipmentBoily.CalculateValue();
|
|
}
|
|
}
|
|
|
|
public Vector2 GetEquipmentPriceAndLevel(EquipmentObject.EquipmentType equipmentType, float value)
|
|
{
|
|
Vector2 one = Vector2.one;
|
|
if (value < 0f)
|
|
{
|
|
return -one;
|
|
}
|
|
bool flag = value > 1f;
|
|
if (flag)
|
|
{
|
|
value -= 1f;
|
|
}
|
|
value = Mathf.Pow(value, 1.5f);
|
|
switch (equipmentType)
|
|
{
|
|
case EquipmentObject.EquipmentType.ROD:
|
|
one.x = Mathf.Lerp(priceRod.x, priceRod.y, value);
|
|
break;
|
|
case EquipmentObject.EquipmentType.ICE_ROD:
|
|
one.x = Mathf.Lerp(priceIceRod.x, priceIceRod.y, value);
|
|
break;
|
|
case EquipmentObject.EquipmentType.REEL:
|
|
one.x = Mathf.Lerp(priceReel.x, priceReel.y, value);
|
|
break;
|
|
case EquipmentObject.EquipmentType.LINE:
|
|
one.x = Mathf.Lerp(priceLine.x, priceLine.y, value);
|
|
break;
|
|
case EquipmentObject.EquipmentType.FLOAT:
|
|
one.x = Mathf.Lerp(priceFloat.x, priceFloat.y, value);
|
|
break;
|
|
case EquipmentObject.EquipmentType.BAIT:
|
|
one.x = Mathf.Lerp(priceBait.x, priceBait.y, value);
|
|
break;
|
|
case EquipmentObject.EquipmentType.HOOK:
|
|
one.x = Mathf.Lerp(priceHook.x, priceHook.y, value);
|
|
break;
|
|
}
|
|
one.x *= globalPriceMultiplier;
|
|
if (equipmentType == EquipmentObject.EquipmentType.REEL)
|
|
{
|
|
value *= 1.2f;
|
|
}
|
|
one.y = Mathf.Lerp(0f, (int)playerSettings.maxPlayerLevelPrices, value);
|
|
one.y = Mathf.Clamp(one.y, 1f, (int)playerSettings.maxPlayerLevel);
|
|
if (flag)
|
|
{
|
|
switch (equipmentType)
|
|
{
|
|
case EquipmentObject.EquipmentType.ROD:
|
|
one.x += priceRod.y;
|
|
break;
|
|
case EquipmentObject.EquipmentType.REEL:
|
|
one.x += priceReel.y;
|
|
break;
|
|
case EquipmentObject.EquipmentType.LINE:
|
|
one.x += priceLine.y;
|
|
break;
|
|
}
|
|
one.y = (float)(int)playerSettings.maxPlayerLevelPrices + 1f;
|
|
}
|
|
return one;
|
|
}
|
|
|
|
[Button]
|
|
public void CalculateEquipmentCount()
|
|
{
|
|
equipmentCount = 0;
|
|
equipmentCount += equipmentRods.Count;
|
|
equipmentCount += equipmentIceRods.Count;
|
|
equipmentCount += equipmentReels.Count;
|
|
equipmentCount += equipmentLines.Count;
|
|
equipmentCount += equipmentFloats.Count;
|
|
equipmentCount += equipmentBaits.Count;
|
|
equipmentCount += equipmentOther.Count;
|
|
equipmentCount += equipmentRods.Count;
|
|
equipmentCount += equipmentNormalHooks.Count;
|
|
equipmentCount += equipmentSpinners.Count;
|
|
equipmentCount += equipmentSpoons.Count;
|
|
equipmentCount += equipmentWobblers.Count;
|
|
equipmentCount += equipmentSoftBaits.Count;
|
|
}
|
|
|
|
[Button]
|
|
public void CopyRodsToTypes()
|
|
{
|
|
for (int i = 0; i < equipmentRods.Count; i++)
|
|
{
|
|
switch (equipmentRods[i].prefab.GetComponent<FishingRod>().rodType)
|
|
{
|
|
case FishingRod.RodType.SPINNING:
|
|
equipmentRodsSpinning.Add(equipmentRods[i]);
|
|
break;
|
|
case FishingRod.RodType.CASTING:
|
|
equipmentRodsCasting.Add(equipmentRods[i]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
[Button]
|
|
public void CopyReelsToTypes()
|
|
{
|
|
for (int i = 0; i < equipmentReels.Count; i++)
|
|
{
|
|
switch (equipmentReels[i].prefab.GetComponent<FishingReel>().reelType)
|
|
{
|
|
case FishingReel.ReelType.STANDARD:
|
|
equipmentReelsStandard.Add(equipmentReels[i]);
|
|
break;
|
|
case FishingReel.ReelType.LINE_COUNTER:
|
|
equipmentReelsLineCounter.Add(equipmentReels[i]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
[Button]
|
|
public void ShuffleRods()
|
|
{
|
|
Utilities.Shuffle(equipmentFishingRods);
|
|
}
|
|
|
|
[Button]
|
|
public void CalculateRodParams()
|
|
{
|
|
float num = 19f;
|
|
for (int i = 0; i < equipmentFishingRods.Count; i++)
|
|
{
|
|
float num2 = num;
|
|
float num3 = UnityEngine.Random.Range(-1f, 1f);
|
|
num3 = num3 * num * 0.25f;
|
|
equipmentFishingRods[i].durability = Mathf.Clamp01((num2 + num3) / 100f);
|
|
num += 3.4f;
|
|
}
|
|
Debug.Log("currentValue: " + num);
|
|
}
|
|
|
|
[Button]
|
|
public void ShuffleReels()
|
|
{
|
|
Utilities.Shuffle(equipmentFishingReels);
|
|
}
|
|
|
|
[Button]
|
|
public void CalculateReelParams()
|
|
{
|
|
float num = 22f;
|
|
for (int i = 0; i < equipmentFishingReels.Count; i++)
|
|
{
|
|
float num2 = num;
|
|
float num3 = num;
|
|
float num4 = num;
|
|
float num5 = UnityEngine.Random.Range(-1f, 1f);
|
|
num5 = num5 * num * 0.25f;
|
|
equipmentFishingReels[i].durability = Mathf.Clamp01((num2 + num5) / 200f);
|
|
equipmentFishingReels[i].dragSteps = Mathf.RoundToInt(Mathf.Clamp01((num3 - num5) / 200f) * (float)FishingReel.maxDragSteps);
|
|
equipmentFishingReels[i].maxLineLength = Mathf.RoundToInt(Mathf.Lerp(6f, 30f, Mathf.Clamp01(num / 200f))) * 10;
|
|
num += 8.5f;
|
|
}
|
|
Debug.Log("currentReelValue: " + num);
|
|
}
|
|
|
|
public bool CheckMinimumRequiredEquipment()
|
|
{
|
|
if (GameController.Instance.iceLevel)
|
|
{
|
|
if (GetCurrentEquipment(EquipmentObject.EquipmentType.ICE_ROD) == null || GetCurrentEquipment(EquipmentObject.EquipmentType.ICE_ROD).prefab == null)
|
|
{
|
|
return false;
|
|
}
|
|
if (GetCurrentEquipment(EquipmentObject.EquipmentType.LINE) == null || GetCurrentEquipment(EquipmentObject.EquipmentType.LINE).prefab == null)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (GetCurrentEquipment(EquipmentObject.EquipmentType.ROD) == null || GetCurrentEquipment(EquipmentObject.EquipmentType.ROD).prefab == null)
|
|
{
|
|
return false;
|
|
}
|
|
if (GetCurrentEquipment(EquipmentObject.EquipmentType.REEL) == null || GetCurrentEquipment(EquipmentObject.EquipmentType.REEL).prefab == null)
|
|
{
|
|
return false;
|
|
}
|
|
if (GetCurrentEquipment(EquipmentObject.EquipmentType.LINE) == null || GetCurrentEquipment(EquipmentObject.EquipmentType.LINE).prefab == null)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
[Button]
|
|
public void TestUnequip()
|
|
{
|
|
List<EquipmentObject> list = equipmentSets[0];
|
|
for (int i = 0; i < list.Count; i++)
|
|
{
|
|
UnequipObject((EquipmentObject.EquipmentType)i);
|
|
}
|
|
}
|
|
|
|
[Button]
|
|
public void TestUnequipRod()
|
|
{
|
|
List<EquipmentObject> list = equipmentSets[0];
|
|
UnequipObject(EquipmentObject.EquipmentType.ROD);
|
|
}
|
|
|
|
[Button]
|
|
public void CheckStartEquipment()
|
|
{
|
|
if ((int)GlobalSettings.Instance.playerSettings.playersExperience > 0)
|
|
{
|
|
return;
|
|
}
|
|
bool flag = true;
|
|
List<EquipmentObject> list = equipmentSets[0];
|
|
for (int i = 0; i < list.Count; i++)
|
|
{
|
|
if (list[i] != null && list[i].prefab != null)
|
|
{
|
|
flag = false;
|
|
break;
|
|
}
|
|
}
|
|
if (flag)
|
|
{
|
|
Debug.LogError("CheckStartEquipment sthWrong");
|
|
Reset();
|
|
}
|
|
}
|
|
|
|
public bool CanBeSold(EquipmentObject equipmentObject)
|
|
{
|
|
return !IsThisStartEquipment(equipmentObject);
|
|
}
|
|
|
|
public bool IsThisStartEquipment(EquipmentObject equipmentObject)
|
|
{
|
|
if ((int)equipmentObject.equipmentType >= startEquipment.Count)
|
|
{
|
|
return false;
|
|
}
|
|
return startEquipment[(int)equipmentObject.equipmentType] == equipmentObject.id;
|
|
}
|
|
|
|
public void AddFakeBaits()
|
|
{
|
|
EquipmentObject equipmentObject = FindEquipment(EquipmentObject.EquipmentType.BAIT, startEquipment[6]);
|
|
if (equipmentObject.amount == 0 && (int)playerSettings.playersMoney < equipmentObject.price)
|
|
{
|
|
equipmentObject.amount = 1;
|
|
Debug.LogError("AddFakeBaits");
|
|
}
|
|
}
|
|
|
|
public void Save()
|
|
{
|
|
string currentProfilePrefix = GlobalSettings.Instance.saveManager.GetCurrentProfilePrefix();
|
|
using (ES2Writer eS2Writer = ES2Writer.Create(currentProfilePrefix))
|
|
{
|
|
for (int i = 0; i < 13; i++)
|
|
{
|
|
List<EquipmentObject> equipmentList = GetEquipmentList((EquipmentObject.EquipmentType)i);
|
|
if (equipmentList != null)
|
|
{
|
|
for (int j = 0; j < equipmentList.Count; j++)
|
|
{
|
|
eS2Writer.Write(equipmentList[j].isBought, equipmentList[j].id + "_isBought");
|
|
eS2Writer.Write(equipmentList[j].amount, equipmentList[j].id + "_amount");
|
|
}
|
|
}
|
|
}
|
|
for (int k = 0; k < equipmentSets.Length; k++)
|
|
{
|
|
string text = ((k != 0) ? (k + 1 + "_") : string.Empty);
|
|
List<EquipmentObject> list = equipmentSets[k];
|
|
for (int l = 0; l < list.Count; l++)
|
|
{
|
|
if (list[l] != null)
|
|
{
|
|
string id = list[l].id;
|
|
EquipmentObject.EquipmentType equipmentType = (EquipmentObject.EquipmentType)l;
|
|
eS2Writer.Write(id, "currentEquipment_" + text + equipmentType);
|
|
}
|
|
else
|
|
{
|
|
string empty = string.Empty;
|
|
EquipmentObject.EquipmentType equipmentType2 = (EquipmentObject.EquipmentType)l;
|
|
eS2Writer.Write(empty, "currentEquipment_" + text + equipmentType2);
|
|
}
|
|
}
|
|
List<EquipmentObject> list2 = baitsSets[k];
|
|
for (int m = 0; m < list2.Count; m++)
|
|
{
|
|
if (list2[m] != null)
|
|
{
|
|
eS2Writer.Write(list2[m].id, "currentBaits_" + text + m);
|
|
}
|
|
else
|
|
{
|
|
eS2Writer.Write(string.Empty, "currentBaits_" + text + m);
|
|
}
|
|
}
|
|
eS2Writer.Write(setSpecificParameters[k].currentFloatDepth, "currentFloatDepth" + text);
|
|
eS2Writer.Write(setSpecificParameters[k].currentFloatWeight, "currentFloatWeight" + text);
|
|
eS2Writer.Write(setSpecificParameters[k].currentHookSize, "currentHookSize" + text);
|
|
}
|
|
try
|
|
{
|
|
eS2Writer.Save();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
Debug.LogException(exception, this);
|
|
}
|
|
Debug.Log("Save Equipment");
|
|
}
|
|
}
|
|
|
|
public void Load()
|
|
{
|
|
string currentProfilePrefix = GlobalSettings.Instance.saveManager.GetCurrentProfilePrefix();
|
|
using (ES2Reader reader = ES2Reader.Create(currentProfilePrefix))
|
|
{
|
|
for (int i = 0; i < 13; i++)
|
|
{
|
|
List<EquipmentObject> equipmentList = GetEquipmentList((EquipmentObject.EquipmentType)i);
|
|
if (equipmentList == null)
|
|
{
|
|
continue;
|
|
}
|
|
for (int j = 0; j < equipmentList.Count; j++)
|
|
{
|
|
equipmentList[j].isBought = SaveManager.Read(reader, equipmentList[j].id + "_isBought", false);
|
|
equipmentList[j].amount = SaveManager.Read(reader, equipmentList[j].id + "_amount", (!equipmentList[j].hasAmount) ? (-1) : 0);
|
|
if (equipmentList[j].hasAmount && equipmentList[j].amount < 0)
|
|
{
|
|
equipmentList[j].amount = 0;
|
|
}
|
|
if (equipmentList[j].hasAmount && equipmentList[j].amount < 0 && equipmentList[j].isBought && !equipmentList[j].isEquipped)
|
|
{
|
|
equipmentList[j].amount = 1;
|
|
}
|
|
if (equipmentList[j].isBought && equipmentList[j].IsBuyAndEquip())
|
|
{
|
|
equipmentList[j].isEquipped = true;
|
|
}
|
|
}
|
|
}
|
|
for (int k = 0; k < equipmentSets.Length; k++)
|
|
{
|
|
string text = ((k != 0) ? (k + 1 + "_") : string.Empty);
|
|
List<EquipmentObject> list = equipmentSets[k];
|
|
for (int l = 0; l < list.Count; l++)
|
|
{
|
|
EquipmentObject.EquipmentType equipmentType = (EquipmentObject.EquipmentType)l;
|
|
string id = SaveManager.Read(reader, "currentEquipment_" + text + equipmentType, string.Empty);
|
|
EquipmentObject equipmentObject = FindEquipment((EquipmentObject.EquipmentType)l, id);
|
|
if (equipmentObject != null)
|
|
{
|
|
EquipObject(equipmentObject, k);
|
|
}
|
|
else
|
|
{
|
|
UnequipObject((EquipmentObject.EquipmentType)l, k);
|
|
}
|
|
}
|
|
List<EquipmentObject> list2 = baitsSets[k];
|
|
for (int m = 0; m < list2.Count; m++)
|
|
{
|
|
string text2 = SaveManager.Read(reader, "currentBaits_" + text + m, string.Empty);
|
|
EquipmentObject equipmentObject2 = FindEquipment(EquipmentObject.EquipmentType.BAIT, text2);
|
|
if (equipmentObject2 != null && text2 != string.Empty)
|
|
{
|
|
EquipObject(equipmentObject2, k, m);
|
|
}
|
|
else
|
|
{
|
|
UnequipObject(EquipmentObject.EquipmentType.BAIT, k, m);
|
|
}
|
|
}
|
|
setSpecificParameters[k].currentFloatDepth = SaveManager.Read(reader, "currentFloatDepth" + text, 50f);
|
|
setSpecificParameters[k].currentFloatWeight = SaveManager.Read(reader, "currentFloatWeight" + text, 2f);
|
|
setSpecificParameters[k].currentHookSize = SaveManager.Read(reader, "currentHookSize" + text, 0f);
|
|
}
|
|
}
|
|
AddFakeBaits();
|
|
ChangeCurrentEquipmentSet(0);
|
|
Debug.Log("Load Equipment");
|
|
}
|
|
|
|
public void Reset()
|
|
{
|
|
if (GlobalSettings.Instance.currentPlatform == GlobalSettings.Platform.ARCADE)
|
|
{
|
|
return;
|
|
}
|
|
for (int i = 0; i < 13; i++)
|
|
{
|
|
List<EquipmentObject> equipmentList = GetEquipmentList((EquipmentObject.EquipmentType)i);
|
|
if (equipmentList == null)
|
|
{
|
|
continue;
|
|
}
|
|
for (int j = 0; j < equipmentList.Count; j++)
|
|
{
|
|
equipmentList[j].isBought = equipmentList[j].isBoughtAtStart;
|
|
equipmentList[j].isEquipped = false;
|
|
if (equipmentList[j].equipmentSubType == EquipmentObject.EquipmentSubType.FLOAT_WEIGHT)
|
|
{
|
|
equipmentList[j].amount = 2;
|
|
}
|
|
else
|
|
{
|
|
equipmentList[j].amount = ((!equipmentList[j].hasAmount) ? (-1) : 0);
|
|
}
|
|
}
|
|
}
|
|
EquipmentObject equipmentObject = FindEquipment(EquipmentObject.EquipmentType.HOOK, "HOOK_GNOME_MIKADO_01");
|
|
equipmentObject.isBought = true;
|
|
equipmentObject.amount = 1;
|
|
RefreshStartEquipment();
|
|
Debug.Log("Reset Equipment");
|
|
Save();
|
|
}
|
|
|
|
public void RefreshStartEquipment()
|
|
{
|
|
for (int i = 0; i < equipmentSets.Length; i++)
|
|
{
|
|
string text = ((i != 0) ? (i + 1 + "_") : string.Empty);
|
|
List<EquipmentObject> list = baitsSets[i];
|
|
for (int j = 0; j < list.Count; j++)
|
|
{
|
|
UnequipObject(EquipmentObject.EquipmentType.BAIT, i, j);
|
|
}
|
|
List<EquipmentObject> list2 = equipmentSets[i];
|
|
for (int k = 0; k < list2.Count; k++)
|
|
{
|
|
EquipmentObject equipmentObject = FindEquipment((EquipmentObject.EquipmentType)k, startEquipment[k]);
|
|
if (equipmentObject != null)
|
|
{
|
|
switch (k)
|
|
{
|
|
case 5:
|
|
equipmentObject.amount = 1;
|
|
break;
|
|
case 6:
|
|
equipmentObject.amount = 30;
|
|
break;
|
|
default:
|
|
equipmentObject.isBought = true;
|
|
break;
|
|
}
|
|
}
|
|
else if (!string.IsNullOrEmpty(startEquipment[k]))
|
|
{
|
|
Debug.LogError("StartEquipment not found: " + startEquipment[k]);
|
|
}
|
|
if (equipmentObject != null && i == 0)
|
|
{
|
|
EquipObject(equipmentObject, 0);
|
|
}
|
|
else
|
|
{
|
|
UnequipObject((EquipmentObject.EquipmentType)k, i);
|
|
}
|
|
}
|
|
setSpecificParameters[i].currentFloatDepth = 50f;
|
|
setSpecificParameters[i].currentFloatWeight = 2f;
|
|
setSpecificParameters[i].currentHookSize = 3f;
|
|
}
|
|
}
|
|
}
|