675 lines
18 KiB
C#
675 lines
18 KiB
C#
using System;
|
|
using UFS2.Gameplay;
|
|
using UnityEngine;
|
|
using UnityEngine.Events;
|
|
|
|
public class FReel : MonoBehaviour
|
|
{
|
|
public enum Type
|
|
{
|
|
Normal = 0,
|
|
Casting = 1
|
|
}
|
|
|
|
[Serializable]
|
|
public class ReelingEvent : UnityEvent<float, Transform>
|
|
{
|
|
}
|
|
|
|
[Serializable]
|
|
public class ReelingUnityEvent : UnityEvent<float, float>
|
|
{
|
|
}
|
|
|
|
[Serializable]
|
|
public class SpoolUnityEvent : UnityEvent<float, Transform>
|
|
{
|
|
}
|
|
|
|
[Serializable]
|
|
public class ReelPlayTranform : UnityEvent<Transform>
|
|
{
|
|
}
|
|
|
|
public Type type;
|
|
|
|
public Transform armatureLHandUnlockPoster;
|
|
|
|
public Transform szpulaCenterPoint;
|
|
|
|
public Transform linePointSzpula;
|
|
|
|
public Transform linePointRoter;
|
|
|
|
public Transform lineFingerPoint;
|
|
|
|
public Transform handle;
|
|
|
|
public Transform BailHandle;
|
|
|
|
public Transform SpoolObject;
|
|
|
|
[HideInInspector]
|
|
public bool isBlockLineByFinger;
|
|
|
|
[HideInInspector]
|
|
public bool isBailOpen;
|
|
|
|
[HideInInspector]
|
|
public bool isHandOnHandle;
|
|
|
|
[SerializeField]
|
|
public float reelingSpeed = 1f;
|
|
|
|
private float currentReelingSpeed;
|
|
|
|
private float _reelingDrag = 1f;
|
|
|
|
private float reelSpeedFactor = 3f;
|
|
|
|
private float reelSpeedStep = 1f;
|
|
|
|
private float reelSpeedMax = 1f;
|
|
|
|
private float reelSpeedMin = 0.1f;
|
|
|
|
private float reelDragStep = 0.04f;
|
|
|
|
[HideInInspector]
|
|
public bool isDamaged;
|
|
|
|
public AudioClip[] audioClips;
|
|
|
|
public Animator animator;
|
|
|
|
[HideInInspector]
|
|
public FRod currentRod;
|
|
|
|
public float maxReelStrength = 10f;
|
|
|
|
public float currentReelStrength;
|
|
|
|
private bool lastBailState;
|
|
|
|
private float lastReelingSpeed;
|
|
|
|
private bool isLineOut;
|
|
|
|
private float lineOutAmount;
|
|
|
|
private float lastPhisicsLineOut;
|
|
|
|
private bool isFishFight;
|
|
|
|
private bool isReelDragSlow;
|
|
|
|
private bool isReelDragFast;
|
|
|
|
private float reelDragSlowAmount;
|
|
|
|
private float reelDragFastAmount;
|
|
|
|
public ReelPlayTranform OnReelDamaged;
|
|
|
|
public ReelPlayTranform OnDragValueChanged;
|
|
|
|
private float lineoutAnimSpeed;
|
|
|
|
public ReelPlayTranform OnSpeedValueChanged;
|
|
|
|
public ReelPlayTranform OnBailOpen;
|
|
|
|
public ReelPlayTranform OnBailClose;
|
|
|
|
public ReelingEvent OnReelingStart;
|
|
|
|
public ReelingEvent OnReelingStartDamaged;
|
|
|
|
public ReelingUnityEvent OnReeling;
|
|
|
|
public ReelPlayTranform OnReelingStop;
|
|
|
|
public ReelPlayTranform OnReelingStopDamaged;
|
|
|
|
public SpoolUnityEvent OnThrowSpoolUnwinding;
|
|
|
|
public SpoolUnityEvent OnThrowSpoolUnwindingWithDrag;
|
|
|
|
private bool isThrowingSoundPlayed;
|
|
|
|
private bool isReeling;
|
|
|
|
public float CurretnReelingSpeed
|
|
{
|
|
get
|
|
{
|
|
return currentReelingSpeed;
|
|
}
|
|
set
|
|
{
|
|
currentReelingSpeed = value;
|
|
}
|
|
}
|
|
|
|
[SerializeField]
|
|
public float reelingDrag
|
|
{
|
|
get
|
|
{
|
|
return _reelingDrag;
|
|
}
|
|
set
|
|
{
|
|
_reelingDrag = Mathf.Clamp01(value);
|
|
}
|
|
}
|
|
|
|
public float LinePullingForce => reelingDrag * maxReelStrength;
|
|
|
|
public float CurrentReelStrength01 => currentReelStrength / maxReelStrength;
|
|
|
|
public static event Action<Transform> OnReelDamagedGlobal;
|
|
|
|
public static event Action<Transform> OnDragValueChangedGlobal;
|
|
|
|
public static event Action<Transform> OnSpeedValueChangedGlobal;
|
|
|
|
public static event Action<Transform> OnBailOpenGlobal;
|
|
|
|
public static event Action<Transform> OnBailCloseGlobal;
|
|
|
|
public static event Action<float, Transform> OnReelingStartGlobal;
|
|
|
|
public static event Action<float, Transform> OnReelingStartDamagedGlobal;
|
|
|
|
public static event Action<float, float> OnReelingGlobal;
|
|
|
|
public static event Action<Transform> OnReelingStopGlobal;
|
|
|
|
public static event Action<Transform> OnReelingStopDamagedGlobal;
|
|
|
|
public static event Action<float, Transform> OnThrowSpoolUnwindingGlobal;
|
|
|
|
public static event Action<float, Transform> OnThrowSpoolUnwindingWithDragGlobal;
|
|
|
|
public static event Action<FReel> OnDamage;
|
|
|
|
public static event Action<float, Transform> OnLineOutStartGlobal;
|
|
|
|
public static event Action<float, float> OnLineOutGlobal;
|
|
|
|
public static event Action<Transform> OnLineOutStopGlobal;
|
|
|
|
public static event Action<float, Transform> OnLineBurstSmallStartGlobal;
|
|
|
|
public static event Action<float, float> OnLineBurstSmallGlobal;
|
|
|
|
public static event Action<Transform> OnLineBurstSmallStopGlobal;
|
|
|
|
public static event Action<float, Transform> OnLineBurstMediumStartGlobal;
|
|
|
|
public static event Action<float, float> OnLineBurstMediumGlobal;
|
|
|
|
public static event Action<Transform> OnLineBurstMediumStopGlobal;
|
|
|
|
public static event Action<float, Transform> OnReelDragSlowStartGlobal;
|
|
|
|
public static event Action<float, float> OnReelDragSlowGlobal;
|
|
|
|
public static event Action<Transform> OnReelDragSlowStopGlobal;
|
|
|
|
public static event Action<float, Transform> OnReelDragFastStartGlobal;
|
|
|
|
public static event Action<float, float> OnReelDragFastGlobal;
|
|
|
|
public static event Action<Transform> OnReelDragFastStopGlobal;
|
|
|
|
private void Start()
|
|
{
|
|
lastReelingSpeed = reelingSpeed;
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
if (!isHandOnHandle && CurretnReelingSpeed > 0f)
|
|
{
|
|
CurretnReelingSpeed = 0f;
|
|
animator.SetFloat("Reeling", CurretnReelingSpeed);
|
|
}
|
|
if (!currentRod)
|
|
{
|
|
return;
|
|
}
|
|
LineOutDragByFish();
|
|
if (!currentRod.currentPlayer || !currentRod.fishingLine.currentLineHandler)
|
|
{
|
|
return;
|
|
}
|
|
Reeling();
|
|
SoundsFX();
|
|
LineFX();
|
|
CalculateReeldStrength();
|
|
if (currentRod.currentPlayer.fishingMode == FPlayer.FishingMode.Manual)
|
|
{
|
|
isBlockLineByFinger = InputManager.isBlockLineFinger;
|
|
if (InputManager.isReelUnlockLock && CurretnReelingSpeed == 0f && !isHandOnHandle)
|
|
{
|
|
currentRod.currentPlayer.UnlockLockReel();
|
|
}
|
|
}
|
|
if (currentRod.fishingLine.currentLineHandler.PhisicsLineOut > 0f && !isHandOnHandle && !currentRod.isThrowing && !currentRod.currentPlayer.isLeftHandVisable)
|
|
{
|
|
if ((bool)handle)
|
|
{
|
|
currentRod.currentPlayer.InteractiveLeftHand(handle);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (currentRod.fishingLine.currentLineHandler.PhisicsLineOut != 0f || !isHandOnHandle || currentRod.isThrowing)
|
|
{
|
|
return;
|
|
}
|
|
if ((bool)currentRod.currentFish)
|
|
{
|
|
if (currentRod.currentFish.isGetFish)
|
|
{
|
|
currentRod.currentPlayer.InteractiveLeftHand(null);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
currentRod.currentPlayer.InteractiveLeftHand(null);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void CalculateReeldStrength()
|
|
{
|
|
if ((bool)currentRod && (bool)currentRod.fishingLine && maxReelStrength != 0f)
|
|
{
|
|
currentReelStrength = currentRod.fishingLine.CurrentLineTension;
|
|
}
|
|
}
|
|
|
|
public void Damage()
|
|
{
|
|
if (!isDamaged && !TutorialManager.Instance)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentRod.indexOfslot].SetWearRodReel(GameManager.ItemType.Reel, 0);
|
|
GameManager.Instance.ShowMessagePopup(LanguageManager.Instance.GetText("SET_DAMAGED"), FScriptsHandler.Instance.m_Canvas.transform);
|
|
OnReelDamaged?.Invoke(base.transform);
|
|
FReel.OnReelDamagedGlobal?.Invoke(base.transform);
|
|
isDamaged = true;
|
|
FReel.OnDamage?.Invoke(this);
|
|
FRod.OnEquipmentBreak?.Invoke(currentRod);
|
|
}
|
|
}
|
|
|
|
private void SoundsFX()
|
|
{
|
|
if (lastBailState != isBailOpen)
|
|
{
|
|
if (isBailOpen)
|
|
{
|
|
OnBailOpen?.Invoke(base.transform);
|
|
FReel.OnBailOpenGlobal?.Invoke(base.transform);
|
|
}
|
|
else
|
|
{
|
|
OnBailClose?.Invoke(base.transform);
|
|
FReel.OnBailCloseGlobal?.Invoke(base.transform);
|
|
}
|
|
lastBailState = isBailOpen;
|
|
isThrowingSoundPlayed = false;
|
|
}
|
|
if (CurretnReelingSpeed > 0f)
|
|
{
|
|
float num = 0.2f;
|
|
OnReeling?.Invoke(CurretnReelingSpeed * num, CurretnReelingSpeed * num);
|
|
FReel.OnReelingGlobal?.Invoke(CurretnReelingSpeed * num, CurretnReelingSpeed * num);
|
|
if (!isDamaged)
|
|
{
|
|
if (isReeling)
|
|
{
|
|
return;
|
|
}
|
|
OnReelingStart?.Invoke(CurretnReelingSpeed * num, base.transform);
|
|
FReel.OnReelingStartGlobal?.Invoke(CurretnReelingSpeed * num, base.transform);
|
|
isReeling = true;
|
|
}
|
|
else
|
|
{
|
|
if (isReeling)
|
|
{
|
|
return;
|
|
}
|
|
OnReelingStartDamaged?.Invoke(CurretnReelingSpeed * num, base.transform);
|
|
FReel.OnReelingStartDamagedGlobal?.Invoke(CurretnReelingSpeed * num, base.transform);
|
|
isReeling = true;
|
|
}
|
|
isThrowingSoundPlayed = false;
|
|
}
|
|
else if (!isDamaged)
|
|
{
|
|
if (!isReeling)
|
|
{
|
|
return;
|
|
}
|
|
OnReelingStop?.Invoke(base.transform);
|
|
FReel.OnReelingStopGlobal?.Invoke(base.transform);
|
|
isReeling = false;
|
|
}
|
|
else
|
|
{
|
|
if (!isReeling)
|
|
{
|
|
return;
|
|
}
|
|
OnReelingStopDamaged?.Invoke(base.transform);
|
|
FReel.OnReelingStopDamagedGlobal?.Invoke(base.transform);
|
|
isReeling = false;
|
|
}
|
|
if (animator.GetBool("LineOutunlock") && !currentRod.LureHookWaterDisplacement.IsInWater && currentRod.isThrowing && !isThrowingSoundPlayed)
|
|
{
|
|
OnThrowSpoolUnwinding?.Invoke(1f, base.transform);
|
|
FReel.OnThrowSpoolUnwindingGlobal?.Invoke(1f, base.transform);
|
|
isThrowingSoundPlayed = true;
|
|
}
|
|
else if (lineoutAnimSpeed > 0f)
|
|
{
|
|
Debug.Log("LineoutAnimSpeed transform: " + base.transform);
|
|
OnThrowSpoolUnwindingWithDrag?.Invoke(animator.GetFloat("LineOut"), base.transform);
|
|
FReel.OnThrowSpoolUnwindingWithDragGlobal?.Invoke(animator.GetFloat("LineOut"), base.transform);
|
|
}
|
|
}
|
|
|
|
private void LineFX()
|
|
{
|
|
float pitchMultiplier = 0.02f;
|
|
float num = (currentRod.fishingLine.currentLineHandler.PhisicsLineOut - lastPhisicsLineOut) * Time.deltaTime;
|
|
lastPhisicsLineOut = currentRod.fishingLine.currentLineHandler.PhisicsLineOut;
|
|
if (num > 0f && isBailOpen && currentRod.currentPlayer.throwMode != FPlayer.ThrowMode.Near && CurretnReelingSpeed <= 0f && FishEntity.CurrentFishInFight == null)
|
|
{
|
|
lineOutAmount = Mathf.MoveTowards(lineOutAmount, 1f, Time.deltaTime * 5f);
|
|
}
|
|
else
|
|
{
|
|
lineOutAmount = Mathf.MoveTowards(lineOutAmount, 0f, Time.deltaTime * 3f);
|
|
}
|
|
HandleEffect(lineOutAmount, pitchMultiplier, ref isLineOut, ref FReel.OnLineOutStartGlobal, ref FReel.OnLineOutGlobal, ref FReel.OnLineOutStopGlobal);
|
|
if (FishEntity.CurrentFishInFight == null)
|
|
{
|
|
if (isFishFight)
|
|
{
|
|
isFishFight = false;
|
|
FReel.OnLineBurstSmallStopGlobal?.Invoke(base.transform);
|
|
FReel.OnLineBurstMediumStopGlobal?.Invoke(base.transform);
|
|
}
|
|
}
|
|
else if (!isFishFight)
|
|
{
|
|
isFishFight = true;
|
|
if (reelingDrag < 0.95f)
|
|
{
|
|
pitchMultiplier = Mathf.Lerp(1f, 0.5f, reelingDrag);
|
|
if (FishEntity.CurrentFishInFight.Weight < 35f)
|
|
{
|
|
FReel.OnLineBurstSmallStartGlobal?.Invoke(pitchMultiplier, base.transform);
|
|
}
|
|
else
|
|
{
|
|
FReel.OnLineBurstMediumStartGlobal?.Invoke(pitchMultiplier, base.transform);
|
|
}
|
|
}
|
|
}
|
|
if (num <= 0f || FishEntity.CurrentFishInFight == null)
|
|
{
|
|
reelDragSlowAmount = Mathf.MoveTowards(reelDragSlowAmount, 0f, Time.deltaTime * 3f);
|
|
reelDragFastAmount = Mathf.MoveTowards(reelDragFastAmount, 0f, Time.deltaTime * 3f);
|
|
}
|
|
else if (num < 0.0007f)
|
|
{
|
|
reelDragSlowAmount = Mathf.MoveTowards(reelDragSlowAmount, 1f, Time.deltaTime * 15f);
|
|
reelDragFastAmount = Mathf.MoveTowards(reelDragFastAmount, 0f, Time.deltaTime * 3f);
|
|
}
|
|
else
|
|
{
|
|
reelDragSlowAmount = Mathf.MoveTowards(reelDragSlowAmount, 0f, Time.deltaTime * 3f);
|
|
reelDragFastAmount = Mathf.MoveTowards(reelDragFastAmount, 1f, Time.deltaTime * 15f);
|
|
}
|
|
pitchMultiplier = 1f;
|
|
HandleEffect(reelDragSlowAmount, pitchMultiplier, ref isReelDragSlow, ref FReel.OnReelDragSlowStartGlobal, ref FReel.OnReelDragSlowGlobal, ref FReel.OnReelDragSlowStopGlobal);
|
|
HandleEffect(reelDragFastAmount, pitchMultiplier, ref isReelDragFast, ref FReel.OnReelDragFastStartGlobal, ref FReel.OnReelDragFastGlobal, ref FReel.OnReelDragFastStopGlobal);
|
|
void HandleEffect(float effectAmount, float num2, ref bool isEffectPlaying, ref Action<float, Transform> onEffectStart, ref Action<float, float> onEffectPitch, ref Action<Transform> onEffectStop)
|
|
{
|
|
if (effectAmount > 0f)
|
|
{
|
|
if (!isEffectPlaying)
|
|
{
|
|
isEffectPlaying = true;
|
|
onEffectStart?.Invoke(effectAmount * num2, base.transform);
|
|
}
|
|
onEffectPitch?.Invoke(effectAmount * num2, effectAmount * num2);
|
|
}
|
|
else if (isEffectPlaying)
|
|
{
|
|
isEffectPlaying = false;
|
|
onEffectStop?.Invoke(base.transform);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void PlayChangeDragSound()
|
|
{
|
|
}
|
|
|
|
private bool CanReel()
|
|
{
|
|
if (Singleton<AnglerViewFish>.Instance != null)
|
|
{
|
|
return false;
|
|
}
|
|
if (SRDebug.Instance.IsDebugPanelVisible)
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private void Reeling()
|
|
{
|
|
if (!CanReel())
|
|
{
|
|
return;
|
|
}
|
|
if (InputManager.isReelSpeedUp)
|
|
{
|
|
reelingSpeed += Time.deltaTime * reelSpeedStep * 0.2f;
|
|
lastReelingSpeed = reelingSpeed;
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentRod.indexOfslot].SetReelSettings(0, reelingSpeed);
|
|
OnSpeedValueChanged?.Invoke(base.transform);
|
|
FReel.OnSpeedValueChangedGlobal?.Invoke(base.transform);
|
|
}
|
|
if (InputManager.isReelSpeedDown)
|
|
{
|
|
reelingSpeed -= Time.deltaTime * reelSpeedStep * 0.2f;
|
|
lastReelingSpeed = reelingSpeed;
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentRod.indexOfslot].SetReelSettings(0, reelingSpeed);
|
|
OnSpeedValueChanged?.Invoke(base.transform);
|
|
FReel.OnSpeedValueChangedGlobal?.Invoke(base.transform);
|
|
}
|
|
if (InputManager.isReelDragUp)
|
|
{
|
|
reelingDrag += reelDragStep;
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentRod.indexOfslot].SetReelSettings(1, reelingDrag);
|
|
FReel.OnDragValueChangedGlobal?.Invoke(base.transform);
|
|
}
|
|
if (InputManager.isReelDragDown)
|
|
{
|
|
reelingDrag -= reelDragStep;
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentRod.indexOfslot].SetReelSettings(1, reelingDrag);
|
|
FReel.OnDragValueChangedGlobal?.Invoke(base.transform);
|
|
}
|
|
if (FScriptsHandler.Instance.m_HudManager.selectorRodSetting == HudManager.SelectorRodSetting.Speed && Input.mouseScrollDelta.y != 0f && Time.timeScale != 0f)
|
|
{
|
|
reelingSpeed += Input.mouseScrollDelta.y * 0.04f;
|
|
lastReelingSpeed = reelingSpeed;
|
|
FReel.OnSpeedValueChangedGlobal?.Invoke(base.transform);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentRod.indexOfslot].SetReelSettings(0, reelingSpeed);
|
|
}
|
|
if (FScriptsHandler.Instance.m_HudManager.selectorRodSetting == HudManager.SelectorRodSetting.Drag && Input.mouseScrollDelta.y != 0f && Time.timeScale != 0f)
|
|
{
|
|
reelingDrag += Input.mouseScrollDelta.y * 0.04f;
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentRod.indexOfslot].SetReelSettings(1, reelingDrag);
|
|
FReel.OnSpeedValueChangedGlobal?.Invoke(base.transform);
|
|
}
|
|
if (InputManager.isReelSpeedMax)
|
|
{
|
|
reelingSpeed = 1f;
|
|
}
|
|
else
|
|
{
|
|
reelingSpeed = lastReelingSpeed;
|
|
}
|
|
reelingSpeed = Mathf.Clamp(reelingSpeed, reelSpeedMin, reelSpeedMax);
|
|
reelingDrag = Mathf.Clamp(reelingDrag, 0f, 1f);
|
|
if (isDamaged)
|
|
{
|
|
reelingDrag = 0.5f;
|
|
}
|
|
if (!isHandOnHandle)
|
|
{
|
|
CurretnReelingSpeed = 0f;
|
|
animator.SetFloat("Reeling", CurretnReelingSpeed);
|
|
return;
|
|
}
|
|
if (InputManager.isReelReeling)
|
|
{
|
|
if (Mathf.Clamp01(currentRod.fishingLine.linelenghtDiferent) > 0.8f)
|
|
{
|
|
currentReelingSpeed = reelingSpeed * reelSpeedFactor * (1.5f - Mathf.Clamp01(currentRod.fishingLine.linelenghtDiferent));
|
|
}
|
|
else
|
|
{
|
|
currentReelingSpeed = reelingSpeed * reelSpeedFactor;
|
|
}
|
|
CurretnReelingSpeed = reelingSpeed * reelSpeedFactor * currentRod.currentPlayer.GetPlayerHandPower();
|
|
if (GameManager.Instance.controllerType == GameManager.ControllerType.GamePad && currentRod.currentFish != null && currentRod.fishingLine.linelenghtDiferent > 0.8f)
|
|
{
|
|
GameManager.Instance.ControllerVibrate(0.4f, 1);
|
|
}
|
|
if (FScriptsHandler.Instance.m_HudManager.lineCutTimer == 0f)
|
|
{
|
|
if (currentRod.fishingLine.linelenghtDiferent < 0f)
|
|
{
|
|
currentRod.fishingLine.currentLineHandler.PhisicsLineOut = Mathf.MoveTowards(currentRod.fishingLine.currentLineHandler.PhisicsLineOut, 0f, Time.deltaTime * CurretnReelingSpeed * 2f);
|
|
}
|
|
else
|
|
{
|
|
currentRod.fishingLine.currentLineHandler.PhisicsLineOut = Mathf.MoveTowards(currentRod.fishingLine.currentLineHandler.PhisicsLineOut, 0f, Time.deltaTime * CurretnReelingSpeed);
|
|
}
|
|
}
|
|
if (currentRod.fishingLine.currentLineHandler.PhisicsLineOut == 0f && isHandOnHandle)
|
|
{
|
|
currentRod.currentPlayer.InteractiveLeftHand(null);
|
|
InputManager.ResetMouseButtonsTriggers();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CurretnReelingSpeed = 0f;
|
|
}
|
|
animator.SetFloat("Reeling", CurretnReelingSpeed);
|
|
if (isBailOpen && CurretnReelingSpeed > 0f)
|
|
{
|
|
isBailOpen = false;
|
|
animator.SetBool("Lock", value: true);
|
|
}
|
|
}
|
|
|
|
private void LineOutDragByFish()
|
|
{
|
|
if (!isBailOpen)
|
|
{
|
|
if ((bool)currentRod.currentFish || (bool)currentRod.takeFish)
|
|
{
|
|
if ((bool)currentRod.currentFish && currentRod.currentFish.isGetFish)
|
|
{
|
|
lineoutAnimSpeed = 0f;
|
|
animator.SetFloat("LineOut", lineoutAnimSpeed);
|
|
return;
|
|
}
|
|
float num = maxReelStrength * reelingDrag;
|
|
float num2 = 0f;
|
|
if ((bool)currentRod.currentFish)
|
|
{
|
|
num2 = currentRod.currentFish.fishWeight * Mathf.Clamp01(currentRod.fishingLine.linelenghtDiferent);
|
|
}
|
|
if ((bool)currentRod.takeFish)
|
|
{
|
|
num2 = currentRod.takeFish.fishWeight * Mathf.Clamp01(currentRod.fishingLine.linelenghtDiferent);
|
|
}
|
|
if (num2 > num && reelingDrag < 1f)
|
|
{
|
|
currentRod.fishingLine.currentLineHandler.PhisicsLineOut += Time.deltaTime * (5f + currentRod.fishingLine.currentLineStrenght) * (1f - reelingDrag);
|
|
lineoutAnimSpeed = (1f + Mathf.Clamp01(currentRod.fishingLine.linelenghtDiferent)) * (1f - reelingDrag);
|
|
}
|
|
else
|
|
{
|
|
lineoutAnimSpeed = Mathf.MoveTowards(lineoutAnimSpeed, 0f, Time.deltaTime * 0.2f);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
lineoutAnimSpeed = 0f;
|
|
}
|
|
animator.SetFloat("LineOut", lineoutAnimSpeed);
|
|
}
|
|
if (isBailOpen && !isBlockLineByFinger)
|
|
{
|
|
if (currentRod.fishingLine.linelenghtDiferent > 0f)
|
|
{
|
|
currentRod.fishingLine.currentLineHandler.PhisicsLineOut += currentRod.fishingLine.linelenghtDiferent * 1f;
|
|
animator.SetBool("LineOutunlock", value: true);
|
|
}
|
|
else
|
|
{
|
|
animator.SetBool("LineOutunlock", value: false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
animator.SetBool("LineOutunlock", value: false);
|
|
}
|
|
}
|
|
|
|
public void LockUnlockKablag()
|
|
{
|
|
if (type == Type.Casting)
|
|
{
|
|
isBailOpen = !isBailOpen;
|
|
return;
|
|
}
|
|
animator.SetBool("Unlock", value: false);
|
|
animator.SetBool("Lock", value: false);
|
|
if (!isBailOpen)
|
|
{
|
|
animator.SetBool("Unlock", value: true);
|
|
}
|
|
else
|
|
{
|
|
animator.SetBool("Lock", value: true);
|
|
}
|
|
}
|
|
|
|
private void CheckIsBaitIsInWaterAndLockReel()
|
|
{
|
|
Debug.Log("Double");
|
|
if (isBailOpen)
|
|
{
|
|
currentRod.currentPlayer.InteractiveLeftHand(handle);
|
|
}
|
|
}
|
|
}
|