1043 lines
28 KiB
C#
1043 lines
28 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using RootMotion.FinalIK;
|
|
using UFS2.Gameplay;
|
|
using UnityEngine;
|
|
using UnityEngine.Events;
|
|
|
|
public class FRod : MonoBehaviour
|
|
{
|
|
public enum RodType
|
|
{
|
|
Float = 0,
|
|
Spinning = 1,
|
|
Feeder = 2
|
|
}
|
|
|
|
public class LureCastArgs
|
|
{
|
|
public string mapName;
|
|
|
|
public Vector3 playerPosition;
|
|
|
|
public Vector3 LurePosition;
|
|
}
|
|
|
|
[Serializable]
|
|
public class RodPlayTranform : UnityEvent<Transform>
|
|
{
|
|
}
|
|
|
|
[Serializable]
|
|
public class RodWhooshEvent : UnityEvent<float, Transform>
|
|
{
|
|
}
|
|
|
|
public RodType rodType = RodType.Spinning;
|
|
|
|
public GameManager.GameRods.Action action;
|
|
|
|
public Transform armatureHandPoster;
|
|
|
|
public Transform reelContainer;
|
|
|
|
private CCDIK _ccdik;
|
|
|
|
[HideInInspector]
|
|
public bool isDamaged;
|
|
|
|
[HideInInspector]
|
|
public FFishingLine fishingLine;
|
|
|
|
[HideInInspector]
|
|
public FPlayer currentPlayer;
|
|
|
|
[HideInInspector]
|
|
public float throwPower;
|
|
|
|
[HideInInspector]
|
|
public float throwPowerForSounds;
|
|
|
|
[HideInInspector]
|
|
public float throwForcePower;
|
|
|
|
[HideInInspector]
|
|
public float throwForceMaxPower;
|
|
|
|
public float throwMinPower;
|
|
|
|
[HideInInspector]
|
|
public float throwForceMaxNearPower = 300f;
|
|
|
|
public float throwMinNearPower;
|
|
|
|
public float currentRodStrength;
|
|
|
|
public float maxRodStrength = 10f;
|
|
|
|
[HideInInspector]
|
|
public int indexOfslot = -1;
|
|
|
|
public bool isThrowing;
|
|
|
|
private bool isTargetNearThrow;
|
|
|
|
[HideInInspector]
|
|
public float throwNearPower;
|
|
|
|
private bool isTargetFarThrow;
|
|
|
|
private Vector3 newThrowPosition = Vector3.zero;
|
|
|
|
public FWaterDisplacement LureHookWaterDisplacement;
|
|
|
|
public bool isRodCast;
|
|
|
|
private bool isRodTension;
|
|
|
|
public FReel assignReel;
|
|
|
|
[HideInInspector]
|
|
public FReel currentReel;
|
|
|
|
public FLure assignLure;
|
|
|
|
private FLure _currentLure;
|
|
|
|
public FFloat assignFloat;
|
|
|
|
[HideInInspector]
|
|
public FFloat currentFloat;
|
|
|
|
public FHook assignHook;
|
|
|
|
[HideInInspector]
|
|
public FHook currentHook;
|
|
|
|
public FFeeder assignFeeder;
|
|
|
|
[HideInInspector]
|
|
public FFeeder currentFeeder;
|
|
|
|
public FBait assignBait;
|
|
|
|
[HideInInspector]
|
|
public FBait currentBait;
|
|
|
|
public FLine assignLine;
|
|
|
|
[HideInInspector]
|
|
public FLine currentLine;
|
|
|
|
public FWeight assignWeight;
|
|
|
|
[HideInInspector]
|
|
public FWeight currentWeight;
|
|
|
|
public FFish assignFish;
|
|
|
|
[HideInInspector]
|
|
public FFish currentFish;
|
|
|
|
[HideInInspector]
|
|
public FFish takeFish;
|
|
|
|
public FishEntity currentFishEntity;
|
|
|
|
public AudioClip[] audioClips;
|
|
|
|
private AudioSource audioSource;
|
|
|
|
[HideInInspector]
|
|
public RodSupport dropRodTargetSupport;
|
|
|
|
private float bendSmooth = 1f;
|
|
|
|
private List<float> previousWeights = Enumerable.Repeat(0f, 10).ToList();
|
|
|
|
public static Action<FRod> OnEquipmentBreak;
|
|
|
|
public static Action<FRod> OnFishStrike;
|
|
|
|
public static Action<LureCastArgs> OnLureCast;
|
|
|
|
public static Action<FRod> OnRodTakeOut;
|
|
|
|
public RodPlayTranform OnRodDamaged;
|
|
|
|
public RodPlayTranform OnLineCuted;
|
|
|
|
public RodPlayTranform OnFishStriked;
|
|
|
|
public RodWhooshEvent OnRodWhooshStart;
|
|
|
|
public RodWhooshEvent OnRodWhooshEnd;
|
|
|
|
private bool isCastSound;
|
|
|
|
private bool isTensionSound = true;
|
|
|
|
[HideInInspector]
|
|
public bool isStriked;
|
|
|
|
public float CurrentRodStrength01 => currentRodStrength / maxRodStrength;
|
|
|
|
public float CurrentTension01
|
|
{
|
|
get
|
|
{
|
|
float value = 0f;
|
|
if ((bool)currentReel && (bool)fishingLine)
|
|
{
|
|
float linePullingForce = currentReel.LinePullingForce;
|
|
value = Mathf.Min(fishingLine.CurrentLineTension, linePullingForce) / maxRodStrength;
|
|
}
|
|
return Mathf.Clamp01(value);
|
|
}
|
|
}
|
|
|
|
[HideInInspector]
|
|
public FLure currentLure
|
|
{
|
|
get
|
|
{
|
|
return _currentLure;
|
|
}
|
|
set
|
|
{
|
|
FLure.CurrentLure = value;
|
|
_currentLure = value;
|
|
}
|
|
}
|
|
|
|
public static event Action<Transform> OnRodDamagedGlobal;
|
|
|
|
public static event Action<Transform> OnLineCutedGlobal;
|
|
|
|
public static event Action<Transform> OnFishStrikedGlobal;
|
|
|
|
public static event Action<float, Transform> OnRodWhooshStartGlobal;
|
|
|
|
public static event Action<Transform> OnRodWhooshEndGlobal;
|
|
|
|
public static event Action<Transform> OnRodTensionGlobal;
|
|
|
|
public static event Action<FRod> OnDamage;
|
|
|
|
public static event Action OnFishTake;
|
|
|
|
private void Start()
|
|
{
|
|
fishingLine = GetComponent<FFishingLine>();
|
|
SetupAudio();
|
|
SetupIK(10);
|
|
}
|
|
|
|
private void OnPostUpdate()
|
|
{
|
|
fishingLine.RenderLine();
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
BendControll();
|
|
CreateAndRenderWeight();
|
|
if (InputManager.isCastReset)
|
|
{
|
|
CutLine();
|
|
}
|
|
CheckAndConnectReel();
|
|
CheckAndConnectLure();
|
|
CheckAndConnectFloat();
|
|
CheckAndConnectHook();
|
|
CheckAndConnectFeeder();
|
|
CheckAndConnectFish();
|
|
CheckAndConnectBait();
|
|
CheckAndConnectLine();
|
|
CheckAndConnectWeight();
|
|
CalculateRodStrength();
|
|
if ((bool)LureHookWaterDisplacement && fishingLine.linelenghtDiferent > 1f)
|
|
{
|
|
_ = LureHookWaterDisplacement.transform.position.y;
|
|
_ = 0.1f;
|
|
}
|
|
if (isTargetNearThrow)
|
|
{
|
|
if (!isCastSound)
|
|
{
|
|
FRod.OnRodWhooshStartGlobal?.Invoke(throwPower, base.transform);
|
|
isCastSound = true;
|
|
}
|
|
float value = currentPlayer.notValidTargetValue / 20f;
|
|
value = Mathf.Clamp(value, -5f, 5f);
|
|
newThrowPosition = currentPlayer.currentNearThrowTarget.transform.position + base.transform.forward * value;
|
|
newThrowPosition.y = base.transform.position.y + 2f;
|
|
LureHookWaterDisplacement.rigidbody.isKinematic = true;
|
|
LureHookWaterDisplacement.transform.position = Vector3.MoveTowards(LureHookWaterDisplacement.rigidbody.position, newThrowPosition, Time.deltaTime * 15f);
|
|
if ((bool)currentFloat)
|
|
{
|
|
currentFloat.rigidbody.isKinematic = true;
|
|
currentFloat.transform.position = Vector3.MoveTowards(currentFloat.rigidbody.position, newThrowPosition, Time.deltaTime * 14f);
|
|
}
|
|
if ((bool)currentFeeder)
|
|
{
|
|
currentFeeder.rigidbody.isKinematic = true;
|
|
currentFeeder.transform.position = Vector3.MoveTowards(currentFeeder.rigidbody.position, newThrowPosition, Time.deltaTime * 14f);
|
|
}
|
|
if (LureHookWaterDisplacement.transform.position == newThrowPosition)
|
|
{
|
|
LureHookWaterDisplacement.rigidbody.isKinematic = false;
|
|
if ((bool)currentFloat)
|
|
{
|
|
currentFloat.rigidbody.isKinematic = false;
|
|
}
|
|
if ((bool)currentFeeder)
|
|
{
|
|
currentFeeder.rigidbody.isKinematic = false;
|
|
}
|
|
isTargetNearThrow = false;
|
|
throwNearPower = 0f;
|
|
currentPlayer.ShowHideNearThrowTarget(Vector3.zero, isHide: true);
|
|
isThrowing = false;
|
|
LureCastArgs lureCastArgs = new LureCastArgs();
|
|
lureCastArgs.playerPosition = currentPlayer.transform.position;
|
|
lureCastArgs.LurePosition = newThrowPosition;
|
|
int sceneID = FScriptsHandler.Instance.m_SceneSettings.sceneID;
|
|
lureCastArgs.mapName = GameManager.Instance.gameLocations[sceneID].name;
|
|
OnLureCast?.Invoke(lureCastArgs);
|
|
FRod.OnRodWhooshEndGlobal?.Invoke(base.transform);
|
|
newThrowPosition = Vector3.zero;
|
|
isRodCast = true;
|
|
isCastSound = false;
|
|
}
|
|
}
|
|
if (!isTargetFarThrow)
|
|
{
|
|
return;
|
|
}
|
|
if (!isCastSound)
|
|
{
|
|
FRod.OnRodWhooshStartGlobal?.Invoke(throwPower, base.transform);
|
|
isCastSound = true;
|
|
}
|
|
if (newThrowPosition == Vector3.zero)
|
|
{
|
|
newThrowPosition = currentPlayer.transform.position + base.transform.forward * throwForcePower;
|
|
}
|
|
float num = Vector3.Distance(base.transform.position, newThrowPosition);
|
|
newThrowPosition.y = base.transform.position.y + 2f + num * 0.1f;
|
|
float num2 = 5f + num * 0.35f;
|
|
LureHookWaterDisplacement.rigidbody.isKinematic = true;
|
|
LureHookWaterDisplacement.transform.position = Vector3.MoveTowards(LureHookWaterDisplacement.rigidbody.position, newThrowPosition, Time.deltaTime * num2);
|
|
if ((bool)currentFloat)
|
|
{
|
|
currentFloat.rigidbody.isKinematic = true;
|
|
currentFloat.transform.position = Vector3.MoveTowards(currentFloat.rigidbody.position, newThrowPosition, Time.deltaTime * (num2 - 1f));
|
|
}
|
|
if ((bool)currentFeeder)
|
|
{
|
|
currentFeeder.rigidbody.isKinematic = true;
|
|
currentFeeder.transform.position = Vector3.MoveTowards(currentFeeder.rigidbody.position, newThrowPosition, Time.deltaTime * (num2 - 1f));
|
|
}
|
|
if (LureHookWaterDisplacement.transform.position == newThrowPosition)
|
|
{
|
|
LureHookWaterDisplacement.rigidbody.isKinematic = false;
|
|
if ((bool)currentFloat)
|
|
{
|
|
currentFloat.rigidbody.isKinematic = false;
|
|
}
|
|
if ((bool)currentFeeder)
|
|
{
|
|
currentFeeder.rigidbody.isKinematic = false;
|
|
}
|
|
isTargetFarThrow = false;
|
|
throwForcePower = 0f;
|
|
isThrowing = false;
|
|
LureCastArgs lureCastArgs2 = new LureCastArgs();
|
|
lureCastArgs2.playerPosition = currentPlayer.transform.position;
|
|
lureCastArgs2.LurePosition = newThrowPosition;
|
|
int sceneID2 = FScriptsHandler.Instance.m_SceneSettings.sceneID;
|
|
lureCastArgs2.mapName = GameManager.Instance.gameLocations[sceneID2].name;
|
|
OnLureCast?.Invoke(lureCastArgs2);
|
|
FRod.OnRodWhooshEndGlobal(base.transform);
|
|
newThrowPosition = Vector3.zero;
|
|
isRodCast = true;
|
|
isCastSound = false;
|
|
}
|
|
}
|
|
|
|
public bool CheckIsInUse()
|
|
{
|
|
if (isThrowing)
|
|
{
|
|
return true;
|
|
}
|
|
if (throwPower > 0f)
|
|
{
|
|
return true;
|
|
}
|
|
if ((bool)currentHook)
|
|
{
|
|
if (fishingLine.currentLineHandler.PhisicsLineOut == 0f)
|
|
{
|
|
return false;
|
|
}
|
|
if (currentHook.transform.position.y < 0f)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
if ((bool)currentLure)
|
|
{
|
|
if (fishingLine.currentLineHandler.PhisicsLineOut == 0f)
|
|
{
|
|
return false;
|
|
}
|
|
if (currentLure.transform.position.y < 0f)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
if ((bool)currentFish)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void CreateAndRenderWeight()
|
|
{
|
|
if ((bool)currentWeight && (bool)fishingLine && (bool)fishingLine.currentLineHandler && fishingLine.currentLineHandler.lineType != FLineHandler.LineType.OneSegment)
|
|
{
|
|
int num = fishingLine.currentLineHandler.obiRopeSegment_2.activeParticleCount / 2;
|
|
for (int i = 0; i < currentWeight.weightObjects.Length; i++)
|
|
{
|
|
currentWeight.weightObjects[i].transform.position = fishingLine.currentLineHandler.obiRopeSegment_2.GetParticlePosition(fishingLine.currentLineHandler.obiRopeSegment_2.solverIndices[num + i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void CalculateRodStrength()
|
|
{
|
|
if ((bool)fishingLine && (bool)fishingLine.currentLineHandler && maxRodStrength != 0f)
|
|
{
|
|
currentRodStrength = fishingLine.CurrentLineTension;
|
|
}
|
|
}
|
|
|
|
public void Damage()
|
|
{
|
|
if (!TutorialManager.Instance && !isDamaged && (!fishingLine || fishingLine.rodLinePoints.Length >= 4) && (!currentFish || !currentFish.isGetFish))
|
|
{
|
|
int num = fishingLine.rodLinePoints.Length / 2;
|
|
Transform parent = fishingLine.rodLinePoints[num].parent;
|
|
parent.gameObject.layer = LayerMask.NameToLayer("IgnoreAll");
|
|
Rigidbody rigidbody = fishingLine.rodLinePoints[num + 1].parent.gameObject.AddComponent<Rigidbody>();
|
|
rigidbody.isKinematic = true;
|
|
parent.gameObject.AddComponent<Rigidbody>().drag = 1f;
|
|
rigidbody.isKinematic = true;
|
|
if (!parent.TryGetComponent<ConfigurableJoint>(out var component))
|
|
{
|
|
component = parent.gameObject.AddComponent<ConfigurableJoint>();
|
|
component.xMotion = ConfigurableJointMotion.Locked;
|
|
component.yMotion = ConfigurableJointMotion.Locked;
|
|
component.zMotion = ConfigurableJointMotion.Locked;
|
|
component.angularXMotion = ConfigurableJointMotion.Free;
|
|
component.angularYMotion = ConfigurableJointMotion.Free;
|
|
component.angularZMotion = ConfigurableJointMotion.Free;
|
|
component.connectedBody = rigidbody;
|
|
BoxCollider boxCollider = parent.gameObject.AddComponent<BoxCollider>();
|
|
boxCollider.size = Vector3.one * 0.01f;
|
|
boxCollider.center = new Vector3(-0.1f, 0f, 0f);
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].SetWearRodReel(GameManager.ItemType.Rod, 0);
|
|
OnRodDamaged?.Invoke(base.transform);
|
|
isDamaged = true;
|
|
FRod.OnDamage?.Invoke(this);
|
|
OnEquipmentBreak?.Invoke(this);
|
|
CutLine();
|
|
Invoke("MsgDamaged", 2f);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void MsgDamaged()
|
|
{
|
|
GameManager.Instance.ShowMessagePopup(LanguageManager.Instance.GetText("SET_DAMAGED"), FScriptsHandler.Instance.m_Canvas.transform);
|
|
}
|
|
|
|
public void CutLine(bool destroyBaits = false)
|
|
{
|
|
if (currentPlayer == null)
|
|
{
|
|
return;
|
|
}
|
|
if ((bool)FishEntity.CurrentFishInFight)
|
|
{
|
|
if ((bool)TutorialManager.Instance)
|
|
{
|
|
return;
|
|
}
|
|
GameManager.Instance.ShowMessagePopup(LanguageManager.Instance.GetText("CUT_FISH"), FScriptsHandler.Instance.m_Canvas.transform);
|
|
OnLineCuted?.Invoke(base.transform);
|
|
FRod.OnLineCutedGlobal?.Invoke(base.transform);
|
|
if ((bool)currentHook)
|
|
{
|
|
SubLine(1f);
|
|
}
|
|
if (!TutorialManager.Instance)
|
|
{
|
|
if ((bool)currentLure)
|
|
{
|
|
fishingLine.currentLineHandler.PhisicsLineOut = 0f;
|
|
fishingLine.currentLineHandler.EndLineRigidbody_1.position = fishingLine.currentLineHandler.EndLineRigidbody_0.position;
|
|
isRodCast = false;
|
|
if (!Singleton<SaveDataManager>.Instance.HasCurrentPlayerSkill(GameManager.Skills.iron_bait))
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].SubLastLeaderItemsByCut(GameManager.ItemType.Bait, this);
|
|
}
|
|
SubLine(1f);
|
|
}
|
|
else if ((bool)currentHook)
|
|
{
|
|
if ((bool)currentFloat)
|
|
{
|
|
fishingLine.currentLineHandler.SetSegmentTwoLenght(0.2f);
|
|
}
|
|
if ((bool)currentFloat)
|
|
{
|
|
currentFloat.currentFloatDeepth = 0.2f;
|
|
}
|
|
fishingLine.currentLineHandler.PhisicsLineOut = 0f;
|
|
if ((bool)fishingLine.currentLineHandler.EndLineRigidbody_1)
|
|
{
|
|
fishingLine.currentLineHandler.EndLineRigidbody_1.position = fishingLine.currentLineHandler.EndLineRigidbody_0.position;
|
|
}
|
|
if ((bool)fishingLine.currentLineHandler.EndLineRigidbody_2)
|
|
{
|
|
fishingLine.currentLineHandler.EndLineRigidbody_2.position = fishingLine.currentLineHandler.EndLineRigidbody_0.position;
|
|
}
|
|
if ((bool)fishingLine.currentLineHandler.EndLineRigidbody_3)
|
|
{
|
|
fishingLine.currentLineHandler.EndLineRigidbody_3.position = fishingLine.currentLineHandler.EndLineRigidbody_0.position;
|
|
}
|
|
if ((bool)currentFloat)
|
|
{
|
|
currentFloat.transform.position = fishingLine.currentLineHandler.EndLineRigidbody_0.position;
|
|
}
|
|
if ((bool)currentHook)
|
|
{
|
|
currentHook.transform.position = fishingLine.currentLineHandler.EndLineRigidbody_0.position;
|
|
}
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].SubLastLeaderItemsByCut(GameManager.ItemType.Hook, this);
|
|
isRodCast = false;
|
|
}
|
|
}
|
|
FRod.OnLineCutedGlobal?.Invoke(base.transform);
|
|
return;
|
|
}
|
|
fishingLine.currentLineHandler.PhisicsLineOut = 0f;
|
|
fishingLine.currentLineHandler.ObiLineOut = 0f;
|
|
if ((bool)fishingLine.currentLineHandler.EndLineRigidbody_1)
|
|
{
|
|
fishingLine.currentLineHandler.EndLineRigidbody_1.position = fishingLine.currentLineHandler.EndLineRigidbody_0.position;
|
|
}
|
|
if ((bool)fishingLine.currentLineHandler.EndLineRigidbody_2)
|
|
{
|
|
fishingLine.currentLineHandler.EndLineRigidbody_2.position = fishingLine.currentLineHandler.EndLineRigidbody_0.position;
|
|
}
|
|
if ((bool)fishingLine.currentLineHandler.EndLineRigidbody_3)
|
|
{
|
|
fishingLine.currentLineHandler.EndLineRigidbody_3.position = fishingLine.currentLineHandler.EndLineRigidbody_0.position;
|
|
}
|
|
if ((bool)currentFloat)
|
|
{
|
|
currentFloat.transform.position = fishingLine.currentLineHandler.EndLineRigidbody_0.position;
|
|
}
|
|
if ((bool)currentHook)
|
|
{
|
|
currentHook.transform.position = fishingLine.currentLineHandler.EndLineRigidbody_0.position;
|
|
}
|
|
if ((bool)currentLure)
|
|
{
|
|
currentLure.transform.position = fishingLine.currentLineHandler.EndLineRigidbody_0.position;
|
|
}
|
|
isRodCast = false;
|
|
if (!destroyBaits)
|
|
{
|
|
return;
|
|
}
|
|
if ((bool)currentLure)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].SubLastLeaderItemsByCut(GameManager.ItemType.Bait, this);
|
|
SubLine(1f);
|
|
}
|
|
if ((bool)currentHook)
|
|
{
|
|
if ((bool)currentFloat)
|
|
{
|
|
fishingLine.currentLineHandler.SetSegmentTwoLenght(0.2f);
|
|
}
|
|
if ((bool)currentFloat)
|
|
{
|
|
currentFloat.currentFloatDeepth = 0.2f;
|
|
}
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].SubLastLeaderItemsByCut(GameManager.ItemType.Hook, this);
|
|
SubLine(1f);
|
|
}
|
|
}
|
|
|
|
private void SetupAudio()
|
|
{
|
|
audioSource = base.gameObject.AddComponent<AudioSource>();
|
|
audioSource.playOnAwake = false;
|
|
audioSource.spatialBlend = 1f;
|
|
}
|
|
|
|
private void WhooshSoundsFX(float throwPower)
|
|
{
|
|
if (!audioSource.isPlaying)
|
|
{
|
|
audioSource.pitch = 1f + Mathf.Clamp01(throwPower * 0.001f);
|
|
audioSource.volume = 0f + Mathf.Clamp01(throwPower * 0.0005f);
|
|
audioSource.loop = false;
|
|
audioSource.clip = audioClips[0];
|
|
audioSource.Play();
|
|
}
|
|
}
|
|
|
|
private void WhooshSound()
|
|
{
|
|
}
|
|
|
|
private void DamageSoundsFX()
|
|
{
|
|
if (!audioSource.isPlaying)
|
|
{
|
|
audioSource.pitch = 1.2f;
|
|
audioSource.volume = 0.1f;
|
|
audioSource.loop = false;
|
|
audioSource.clip = audioClips[1];
|
|
audioSource.Play();
|
|
}
|
|
}
|
|
|
|
private void CutLineSoundsFX()
|
|
{
|
|
if (!audioSource.isPlaying)
|
|
{
|
|
audioSource.pitch = 1.2f;
|
|
audioSource.volume = 0.1f;
|
|
audioSource.loop = false;
|
|
audioSource.clip = audioClips[2];
|
|
audioSource.Play();
|
|
}
|
|
}
|
|
|
|
private void StrikeSoundsFX()
|
|
{
|
|
if (!(audioClips[3] == null) && !audioSource.isPlaying)
|
|
{
|
|
audioSource.pitch = 1f;
|
|
audioSource.volume = 0.02f;
|
|
audioSource.loop = false;
|
|
audioSource.clip = audioClips[3];
|
|
audioSource.Play();
|
|
}
|
|
}
|
|
|
|
private void BendControll()
|
|
{
|
|
if (fishingLine.currentLineHandler == null || isDamaged)
|
|
{
|
|
_ccdik.solver.target = null;
|
|
_ccdik.solver.SetIKPositionWeight(0f);
|
|
return;
|
|
}
|
|
Vector3 vector = (FishEntity.CurrentFishInFight ? FishEntity.CurrentFishInFight.transform.position : fishingLine.currentLineHandler.LineConnector_1.transform.position);
|
|
float num = Vector3.Distance(_ccdik.solver.bones.Last().transform.position, vector);
|
|
float num2 = 0.05f;
|
|
if ((bool)FishEntity.CurrentFishInFight)
|
|
{
|
|
float num3 = Vector3.Angle(base.transform.forward, (FishEntity.CurrentFishInFight.transform.position - base.transform.position).normalized) / 180f;
|
|
num2 = Mathf.Clamp(CurrentTension01 * num3, 0.05f, 1f);
|
|
}
|
|
else if (!isThrowing)
|
|
{
|
|
float num4 = 0.3f;
|
|
if ((bool)currentLure)
|
|
{
|
|
num4 *= 0.6f;
|
|
}
|
|
if ((bool)currentFloat)
|
|
{
|
|
num4 *= 0.8f;
|
|
}
|
|
if ((bool)currentFeeder)
|
|
{
|
|
num4 *= 1f;
|
|
}
|
|
float num5 = 1.5f;
|
|
if (num < num5)
|
|
{
|
|
num2 = Mathf.Lerp(num2, num4, 1f - num / num5);
|
|
}
|
|
}
|
|
float num6 = 0.3f;
|
|
if (isThrowing)
|
|
{
|
|
num6 = 0.1f;
|
|
}
|
|
else if (!FishEntity.CurrentFishInFight)
|
|
{
|
|
num6 = 0.2f;
|
|
}
|
|
float target = num2 * num6;
|
|
float item = Mathf.MoveTowards(_ccdik.solver.IKPositionWeight, target, Time.deltaTime * bendSmooth);
|
|
previousWeights.RemoveAt(0);
|
|
previousWeights.Add(item);
|
|
float num7 = previousWeights.Average();
|
|
if ((bool)FishEntity.CurrentFishInFight && FishEntity.CurrentFishInFight.IsCatched)
|
|
{
|
|
num7 = Math.Min(num7, 0.01f);
|
|
}
|
|
_ccdik.solver.SetIKPosition(vector);
|
|
_ccdik.solver.SetIKPositionWeight(num7);
|
|
if ((bool)FishEntity.CurrentFishInFight && (double)num2 > 0.5163254 && !isRodTension)
|
|
{
|
|
isRodTension = true;
|
|
FRod.OnRodTensionGlobal?.Invoke(base.transform);
|
|
}
|
|
else if ((double)num2 < 0.363254 && isRodTension)
|
|
{
|
|
isRodTension = false;
|
|
}
|
|
}
|
|
|
|
private void CheckAndConnectReel()
|
|
{
|
|
if ((bool)assignReel && !(assignReel == currentReel))
|
|
{
|
|
if ((bool)currentReel)
|
|
{
|
|
UnityEngine.Object.Destroy(currentReel.gameObject);
|
|
}
|
|
currentReel = assignReel;
|
|
assignReel = null;
|
|
currentReel.transform.SetParent(reelContainer);
|
|
currentReel.transform.localPosition = Vector3.zero;
|
|
currentReel.transform.localEulerAngles = Vector3.zero;
|
|
currentReel.currentRod = this;
|
|
switch (rodType)
|
|
{
|
|
case RodType.Float:
|
|
fishingLine.CreateObiFishingLine(0);
|
|
break;
|
|
case RodType.Spinning:
|
|
fishingLine.CreateObiFishingLine(1);
|
|
break;
|
|
case RodType.Feeder:
|
|
fishingLine.CreateObiFishingLine(2);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void CheckAndConnectLure()
|
|
{
|
|
if (rodType == RodType.Spinning && (bool)fishingLine.currentLineHandler && (bool)assignLure && !(assignLure == currentLure))
|
|
{
|
|
if ((bool)currentLure)
|
|
{
|
|
UnityEngine.Object.Destroy(currentLure.gameObject);
|
|
LureHookWaterDisplacement = null;
|
|
}
|
|
currentLure = assignLure;
|
|
assignLure = null;
|
|
currentLure.currentRod = this;
|
|
currentLure.transform.position = fishingLine.currentLineHandler.LineConnector_1.transform.position;
|
|
currentLure.gameObject.GetComponent<ConfigurableJoint>().connectedBody = fishingLine.currentLineHandler.LineConnector_1.GetComponent<Rigidbody>();
|
|
LureHookWaterDisplacement = currentLure.GetComponent<FWaterDisplacement>();
|
|
}
|
|
}
|
|
|
|
private void CheckAndConnectHook()
|
|
{
|
|
if ((rodType == RodType.Feeder || rodType == RodType.Float) && (bool)fishingLine.currentLineHandler && (bool)assignHook && !(assignHook == currentHook))
|
|
{
|
|
if ((bool)currentHook)
|
|
{
|
|
UnityEngine.Object.Destroy(currentHook.gameObject);
|
|
LureHookWaterDisplacement = null;
|
|
}
|
|
currentHook = assignHook;
|
|
assignHook = null;
|
|
currentHook.currentRod = this;
|
|
currentHook.transform.position = fishingLine.currentLineHandler.LineConnector_2.transform.position;
|
|
currentHook.gameObject.GetComponent<ConfigurableJoint>().connectedBody = fishingLine.currentLineHandler.LineConnector_2.GetComponent<Rigidbody>();
|
|
LureHookWaterDisplacement = currentHook.GetComponent<FWaterDisplacement>();
|
|
}
|
|
}
|
|
|
|
private void CheckAndConnectFloat()
|
|
{
|
|
if (rodType == RodType.Float && (bool)fishingLine.currentLineHandler && (bool)assignFloat && !(assignFloat == currentFloat))
|
|
{
|
|
if ((bool)currentFloat)
|
|
{
|
|
UnityEngine.Object.Destroy(currentFloat.gameObject);
|
|
}
|
|
currentFloat = assignFloat;
|
|
assignFloat = null;
|
|
currentFloat.currentRod = this;
|
|
currentFloat.transform.position = fishingLine.currentLineHandler.LineConnector_1.transform.position;
|
|
currentFloat.gameObject.GetComponent<ConfigurableJoint>().connectedBody = fishingLine.currentLineHandler.LineConnector_1.GetComponent<Rigidbody>();
|
|
}
|
|
}
|
|
|
|
private void CheckAndConnectFeeder()
|
|
{
|
|
if (rodType == RodType.Feeder && (bool)fishingLine.currentLineHandler && (bool)assignFeeder && !(assignFeeder == currentFeeder))
|
|
{
|
|
if ((bool)currentFeeder)
|
|
{
|
|
UnityEngine.Object.Destroy(currentFeeder.gameObject);
|
|
}
|
|
currentFeeder = assignFeeder;
|
|
assignFeeder = null;
|
|
currentFeeder.currentRod = this;
|
|
currentFeeder.transform.position = fishingLine.currentLineHandler.LineConnector_3.transform.position;
|
|
currentFeeder.gameObject.GetComponent<ConfigurableJoint>().connectedBody = fishingLine.currentLineHandler.LineConnector_3.GetComponent<Rigidbody>();
|
|
}
|
|
}
|
|
|
|
private void CheckAndConnectFish()
|
|
{
|
|
if ((bool)fishingLine.currentLineHandler && (bool)assignFish && !(assignFish == currentFish))
|
|
{
|
|
if ((bool)currentFish)
|
|
{
|
|
UnityEngine.Object.Destroy(currentFish.gameObject);
|
|
}
|
|
currentFish = assignFish;
|
|
assignFish = null;
|
|
OnFishStrike?.Invoke(this);
|
|
}
|
|
}
|
|
|
|
private void CheckAndConnectBait()
|
|
{
|
|
if ((rodType == RodType.Feeder || rodType == RodType.Float) && (bool)fishingLine.currentLineHandler && (bool)assignBait && (bool)currentHook && !(assignBait == currentBait))
|
|
{
|
|
if ((bool)currentBait)
|
|
{
|
|
UnityEngine.Object.Destroy(currentBait.gameObject);
|
|
}
|
|
currentBait = assignBait;
|
|
assignBait = null;
|
|
currentBait.transform.position = currentHook.baitContainer.position;
|
|
currentBait.transform.SetParent(currentHook.baitContainer);
|
|
}
|
|
}
|
|
|
|
private void CheckAndConnectLine()
|
|
{
|
|
if ((bool)fishingLine.currentLineHandler && (bool)assignLine && !(assignLine == currentLine))
|
|
{
|
|
currentLine = assignLine;
|
|
assignLine = null;
|
|
if ((bool)fishingLine.currentLineHandler.obiRopeSegment_1)
|
|
{
|
|
fishingLine.currentLineHandler.obiRopeSegment_1.GetComponent<MeshRenderer>().material = currentLine.lineMat;
|
|
}
|
|
if ((bool)fishingLine.currentLineHandler.obiRopeSegment_2)
|
|
{
|
|
fishingLine.currentLineHandler.obiRopeSegment_2.GetComponent<MeshRenderer>().material = currentLine.lineMat;
|
|
}
|
|
if ((bool)fishingLine.currentLineHandler.obiRopeSegment_3)
|
|
{
|
|
fishingLine.currentLineHandler.obiRopeSegment_3.GetComponent<MeshRenderer>().material = currentLine.lineMat;
|
|
}
|
|
fishingLine.lineRenderer.material = currentLine.lineMat;
|
|
currentReel.SpoolObject.GetComponent<MeshRenderer>().material = currentLine.szpulaMat;
|
|
fishingLine.lineStrenght = currentLine.strength;
|
|
OnRodTakeOut?.Invoke(this);
|
|
}
|
|
}
|
|
|
|
private void CheckAndConnectWeight()
|
|
{
|
|
if ((rodType == RodType.Feeder || rodType == RodType.Float) && (bool)fishingLine.currentLineHandler && (bool)assignWeight && !(assignWeight == currentWeight))
|
|
{
|
|
if ((bool)currentWeight)
|
|
{
|
|
UnityEngine.Object.Destroy(currentWeight.gameObject);
|
|
}
|
|
currentWeight = assignWeight;
|
|
assignWeight = null;
|
|
}
|
|
}
|
|
|
|
public void DestroyCurrentFish()
|
|
{
|
|
Debug.Log("Destroy fish frod");
|
|
if ((bool)currentPlayer.currentChwytak)
|
|
{
|
|
UnityEngine.Object.Destroy(currentPlayer.currentChwytak.gameObject);
|
|
currentPlayer.currentChwytak = null;
|
|
Debug.Log("Destroy chwytak");
|
|
}
|
|
if ((bool)currentFish)
|
|
{
|
|
UnityEngine.Object.Destroy(currentFish.gameObject);
|
|
currentFish = null;
|
|
}
|
|
}
|
|
|
|
public void SetupIK(int maxIterations = 3)
|
|
{
|
|
_ccdik = GetComponent<CCDIK>();
|
|
IKSolverCCD solver = _ccdik.solver;
|
|
solver.OnPostUpdate = (IKSolver.UpdateDelegate)Delegate.Combine(solver.OnPostUpdate, new IKSolver.UpdateDelegate(OnPostUpdate));
|
|
Transform current = _ccdik.solver.bones.FirstOrDefault()?.transform;
|
|
List<Transform> list = new List<Transform>();
|
|
while (current != null && current.parent != null)
|
|
{
|
|
current = current.parent;
|
|
if (!current.name.ToLower().Contains("bone") || _ccdik.solver.bones.Any((IKSolver.Bone b) => b.transform == current) || !(current.GetComponent<FRod>() == null))
|
|
{
|
|
break;
|
|
}
|
|
list.Add(current);
|
|
}
|
|
if (list.Count >= 2)
|
|
{
|
|
List<Transform> list2 = list;
|
|
list2.Reverse();
|
|
list2.RemoveAt(0);
|
|
list2.AddRange(_ccdik.solver.bones.Select((IKSolver.Bone b) => b.transform));
|
|
_ccdik.solver.SetChain(list2.ToArray(), base.transform);
|
|
}
|
|
int num = 14;
|
|
int num2 = 6;
|
|
if (_ccdik.solver.bones.Length > num)
|
|
{
|
|
List<Transform> list3 = _ccdik.solver.bones.Select((IKSolver.Bone element) => element.transform).ToList();
|
|
while (list3.Count > num)
|
|
{
|
|
List<Transform> list4 = new List<Transform>();
|
|
for (int num3 = list3.Count - 2; num3 > num2; num3 -= 2)
|
|
{
|
|
list4.Add(list3[num3].transform);
|
|
}
|
|
for (int num4 = 0; num4 < list4.Count; num4++)
|
|
{
|
|
if (list3.Count <= num)
|
|
{
|
|
break;
|
|
}
|
|
list3.Remove(list4[num4]);
|
|
}
|
|
}
|
|
_ccdik.solver.SetChain(list3.ToArray(), base.transform);
|
|
}
|
|
AnimationCurve rodActionCurve = FScriptsHandler.Instance.GetRodActionCurve(action);
|
|
int num5 = _ccdik.solver.bones.Length;
|
|
for (int num6 = 0; num6 < num5; num6++)
|
|
{
|
|
float time = (float)num6 / (float)(num5 - 1);
|
|
float weight = rodActionCurve.Evaluate(time);
|
|
_ccdik.solver.bones[num6].weight = weight;
|
|
}
|
|
_ccdik.solver.maxIterations = maxIterations;
|
|
_ccdik.solver.tolerance = 0.001f;
|
|
}
|
|
|
|
public void CastFish()
|
|
{
|
|
if (!currentFish && (bool)takeFish)
|
|
{
|
|
Debug.Log("Zaciecie");
|
|
if (fishingLine.linelenghtDiferent > 0f)
|
|
{
|
|
assignFish = takeFish;
|
|
takeFish = null;
|
|
isStriked = false;
|
|
FRod.OnFishTake?.Invoke();
|
|
SubNaturalBait();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void SubNaturalBait()
|
|
{
|
|
if ((bool)currentBait)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].SubNaturalBait(currentBait.gameObject);
|
|
}
|
|
}
|
|
|
|
public void SubLine(float value)
|
|
{
|
|
if ((bool)currentLine)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].SubLine(value);
|
|
}
|
|
}
|
|
|
|
public void ForceThrow(bool isNear = false)
|
|
{
|
|
if ((bool)LureHookWaterDisplacement)
|
|
{
|
|
if ((bool)currentPlayer.currentNearThrowTarget)
|
|
{
|
|
isTargetNearThrow = true;
|
|
}
|
|
else
|
|
{
|
|
isTargetFarThrow = true;
|
|
Debug.Log("Throw Force!!!");
|
|
OnRodWhooshStart?.Invoke(throwPower, base.transform);
|
|
}
|
|
}
|
|
throwPower = 0f;
|
|
}
|
|
|
|
private void OnDestroy()
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].rod.status = GameManager.PlayerData.CRods.Status.InEquip;
|
|
if ((bool)fishingLine)
|
|
{
|
|
fishingLine.DestroyObiLine();
|
|
}
|
|
if ((bool)currentReel)
|
|
{
|
|
UnityEngine.Object.Destroy(currentReel.gameObject);
|
|
}
|
|
if ((bool)currentFloat)
|
|
{
|
|
UnityEngine.Object.Destroy(currentFloat.gameObject);
|
|
}
|
|
if ((bool)currentHook)
|
|
{
|
|
UnityEngine.Object.Destroy(currentHook.gameObject);
|
|
}
|
|
if ((bool)currentLure)
|
|
{
|
|
UnityEngine.Object.Destroy(currentLure.gameObject);
|
|
}
|
|
if ((bool)currentFeeder)
|
|
{
|
|
UnityEngine.Object.Destroy(currentFeeder.gameObject);
|
|
}
|
|
if ((bool)currentFish)
|
|
{
|
|
UnityEngine.Object.Destroy(currentFish.gameObject);
|
|
}
|
|
if ((bool)currentWeight)
|
|
{
|
|
UnityEngine.Object.Destroy(currentWeight.gameObject);
|
|
}
|
|
}
|
|
}
|