1422 lines
45 KiB
C#
1422 lines
45 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using GPUInstancer;
|
|
using Obvious.Soap;
|
|
using UFS2.Gameplay;
|
|
using UnityEngine;
|
|
using UnityStandardAssets.Characters.FirstPerson;
|
|
|
|
public class FPlayer : MonoBehaviour
|
|
{
|
|
public enum FishingMode
|
|
{
|
|
Manual = 0,
|
|
Automatic = 1
|
|
}
|
|
|
|
public enum ThrowMode
|
|
{
|
|
None = 0,
|
|
Near = 1,
|
|
Far = 2
|
|
}
|
|
|
|
public enum FishSize
|
|
{
|
|
VerySmall = 1,
|
|
Small = 6,
|
|
Medium = 35,
|
|
Big = 100
|
|
}
|
|
|
|
public FishingMode fishingMode = FishingMode.Automatic;
|
|
|
|
public ThrowMode throwMode;
|
|
|
|
public Camera m_Camera;
|
|
|
|
public Transform CameraTransform;
|
|
|
|
public Camera m_EagleCamera;
|
|
|
|
public Transform FirstPersonCharacter;
|
|
|
|
public GameObject flashLight;
|
|
|
|
public FirstPersonController firstPersonController;
|
|
|
|
public FullBodyAvatar fullBodyAvatar;
|
|
|
|
public float MouseSensitivityY = 2f;
|
|
|
|
public float MouseSensitivityX = 2f;
|
|
|
|
public FRod assignRod;
|
|
|
|
[HideInInspector]
|
|
public FRod currentRod;
|
|
|
|
[HideInInspector]
|
|
public Chwytak currentChwytak;
|
|
|
|
public bool isLeftHandVisable;
|
|
|
|
[HideInInspector]
|
|
public Transform currentNearThrowTarget;
|
|
|
|
public float notValidTargetValue;
|
|
|
|
[HideInInspector]
|
|
public Camera currentCameraView;
|
|
|
|
[HideInInspector]
|
|
public GameObject underWaterCamera;
|
|
|
|
public AnglerViewFish currentAnglerFishView;
|
|
|
|
[HideInInspector]
|
|
public bool isZoom;
|
|
|
|
[HideInInspector]
|
|
public float lastCameraFov;
|
|
|
|
[SerializeField]
|
|
private UnityStandardAssets.Characters.FirstPerson.MouseLook m_MouseLook;
|
|
|
|
private CharacterController characterController;
|
|
|
|
[HideInInspector]
|
|
private float walkingSpeed = 1f;
|
|
|
|
private float runningSpeed = 2f;
|
|
|
|
private float throwDelay = 2f;
|
|
|
|
private bool isLeftHandConnectLine;
|
|
|
|
private float walkSpeedInWater = 1.7f;
|
|
|
|
private float runSpeedInWater = 2.5f;
|
|
|
|
private bool _PlayerFirstUpdate;
|
|
|
|
private bool isPickingFish;
|
|
|
|
private Vector3 lastPlayerPos;
|
|
|
|
private Vector3 lastBoatPos;
|
|
|
|
[SerializeField]
|
|
private BoolVariable IsThrowFarPreparing;
|
|
|
|
[SerializeField]
|
|
private BoolVariable IsThrowFar;
|
|
|
|
[SerializeField]
|
|
private BoolVariable IsThrowNearPreparing;
|
|
|
|
[SerializeField]
|
|
private BoolVariable IsThrowNear;
|
|
|
|
[SerializeField]
|
|
private FloatVariable ThrowPower;
|
|
|
|
[SerializeField]
|
|
private BoolVariable isFishCanTaken;
|
|
|
|
[SerializeField]
|
|
private Vector3Variable player_CurrentPosition;
|
|
|
|
[SerializeField]
|
|
private Vector2Variable fishMaxWeightToHandsPower;
|
|
|
|
private float fishTakeTime;
|
|
|
|
private Vector3 lastSafeLandPosition;
|
|
|
|
[HideInInspector]
|
|
public float handPullUp;
|
|
|
|
private float rotRodLeftRight;
|
|
|
|
private float rotRodUpDown;
|
|
|
|
private float throwTimer;
|
|
|
|
private FRod currentRodInHand;
|
|
|
|
private Dictionary<Renderer, bool> currentRodRenderers;
|
|
|
|
private List<GameObject> splashStepList = new List<GameObject>();
|
|
|
|
private float delayStepSplash = 0.5f;
|
|
|
|
public Transform CameraPivot
|
|
{
|
|
get
|
|
{
|
|
if (fullBodyAvatar == null)
|
|
{
|
|
fullBodyAvatar = FullBodyAvatar.GetAvatar();
|
|
}
|
|
return fullBodyAvatar.CameraPoint;
|
|
}
|
|
}
|
|
|
|
public FullBodyAvatar FullBodyAvatar
|
|
{
|
|
get
|
|
{
|
|
if (fullBodyAvatar == null)
|
|
{
|
|
fullBodyAvatar = FullBodyAvatar.GetAvatar();
|
|
}
|
|
return fullBodyAvatar;
|
|
}
|
|
}
|
|
|
|
private float fishTakeTimeTarget => 2f;
|
|
|
|
public static event Action OnChangeCameraToUnderwater;
|
|
|
|
public static event Action OnChangeCameraOutUnderwater;
|
|
|
|
public static event Action OnPlayerFirstUpdate;
|
|
|
|
public static event Action<float> OnFishPicking;
|
|
|
|
public static event Action OnFishPicked;
|
|
|
|
public static event Action<FPlayer> OnThrowFar;
|
|
|
|
public static event Action<FPlayer> OnThrowNear;
|
|
|
|
public static event Action<FPlayer> OnRodJam;
|
|
|
|
private void Start()
|
|
{
|
|
GameManager.Instance.SetMouseCurrsor(val: false);
|
|
m_Camera = Camera.main;
|
|
m_EagleCamera.enabled = false;
|
|
currentCameraView = m_Camera;
|
|
characterController = GetComponent<CharacterController>();
|
|
firstPersonController = GetComponent<FirstPersonController>();
|
|
FScriptsHandler.Instance.AffectDisplaySetting();
|
|
FScriptsHandler.Instance.AffectGraphicsSetting();
|
|
FScriptsHandler.Instance.AffectControlsSetting();
|
|
FScriptsHandler.Instance.AffectPostProccesingFromSettings();
|
|
walkingSpeed = firstPersonController.m_WalkSpeed;
|
|
runningSpeed = firstPersonController.m_RunSpeed;
|
|
lastCameraFov = m_Camera.fieldOfView;
|
|
fullBodyAvatar = FullBodyAvatar.GetAvatar();
|
|
fullBodyAvatar.transform.SetParent(base.transform);
|
|
fullBodyAvatar.transform.SetLocalPositionAndRotation(new Vector3(0f, -1f, 0f), Quaternion.identity);
|
|
fullBodyAvatar.SetGender(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSexIndex == 0);
|
|
fullBodyAvatar.ShowHead(toggle: false);
|
|
firstPersonController.cameraTransform = CameraPivot;
|
|
firstPersonController.m_MouseLook.Init(base.transform, CameraPivot);
|
|
InputManager.isHeadFlashLight = false;
|
|
flashLight.SetActive(value: false);
|
|
flashLight.transform.SetParent(fullBodyAvatar.CameraPoint);
|
|
flashLight.transform.SetLocalPositionAndRotation(Vector3.zero, Quaternion.identity);
|
|
RandomizeSpawnPointInMultiplayer();
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
if (Singleton<SceneLoader>.Instance != null)
|
|
{
|
|
return;
|
|
}
|
|
if (_PlayerFirstUpdate)
|
|
{
|
|
FPlayer.OnPlayerFirstUpdate?.Invoke();
|
|
_PlayerFirstUpdate = true;
|
|
}
|
|
firstPersonController.horizontal = InputManager.movementAxis.x;
|
|
firstPersonController.vertical = InputManager.movementAxis.y;
|
|
firstPersonController.isJumping = InputManager.isJumping;
|
|
firstPersonController.isRuning = InputManager.isRunning;
|
|
firstPersonController.m_MouseLook.ControllerHandMode = GameManager.Instance._playerData.Player[GameManager.Instance._playerData.currentPlayerProfileIndex].controllerSetup;
|
|
player_CurrentPosition.Value = base.transform.position;
|
|
CheckAndConnectRod();
|
|
HandsAnimation();
|
|
ThrowInput();
|
|
UnderWaterCameraControler();
|
|
DetectWaterStep();
|
|
FlashlightHandler();
|
|
PickFishHandler();
|
|
ViewAnglerHandler();
|
|
PreventWalkUnderWaterHandler();
|
|
if (firstPersonController.isWater)
|
|
{
|
|
firstPersonController.m_WalkSpeed = walkSpeedInWater;
|
|
firstPersonController.m_RunSpeed = runSpeedInWater;
|
|
}
|
|
else
|
|
{
|
|
firstPersonController.m_WalkSpeed = Mathf.Lerp(firstPersonController.m_WalkSpeed, walkingSpeed * GetReelingForce(), Time.deltaTime * 8f);
|
|
firstPersonController.m_RunSpeed = Mathf.Lerp(firstPersonController.m_RunSpeed, runningSpeed * GetReelingForce(), Time.deltaTime * 8f);
|
|
}
|
|
firstPersonController.m_MouseLook.XSensitivity = Mathf.Lerp(firstPersonController.m_MouseLook.XSensitivity, Singleton<SaveDataManager>.Instance.SettingsData.MouseSensitivityValue * GetPlayerHandPower(), Time.deltaTime * 8f);
|
|
firstPersonController.m_MouseLook.YSensitivity = Mathf.Lerp(firstPersonController.m_MouseLook.YSensitivity, Singleton<SaveDataManager>.Instance.SettingsData.MouseSensitivityValue * GetPlayerHandPower(), Time.deltaTime * 8f);
|
|
if (!currentRod)
|
|
{
|
|
for (int i = 0; i < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods.Count; i++)
|
|
{
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[i].status == GameManager.PlayerData.CRods.Status.InUse)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[i].status = GameManager.PlayerData.CRods.Status.InEquip;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if (throwDelay > 0f && !currentRod.isThrowing)
|
|
{
|
|
throwDelay = Mathf.MoveTowards(throwDelay, 0f, Time.deltaTime);
|
|
}
|
|
if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentRod.indexOfslot].rod.isNull)
|
|
{
|
|
if (currentRod.CheckIsInUse())
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentRod.indexOfslot].rod.status = GameManager.PlayerData.CRods.Status.InUse;
|
|
}
|
|
else
|
|
{
|
|
Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentRod.indexOfslot].rod.status = GameManager.PlayerData.CRods.Status.InHand;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void FixedUpdate()
|
|
{
|
|
Vector3 velocity = Vector3.zero;
|
|
Vector3 baselineVelocity = Vector3.zero;
|
|
if (Time.fixedDeltaTime > 0f)
|
|
{
|
|
velocity = (base.transform.position - lastPlayerPos) / Time.fixedDeltaTime;
|
|
lastPlayerPos = base.transform.position;
|
|
if ((bool)Singleton<Boat>.Instance)
|
|
{
|
|
if ((bool)Singleton<Boat>.Instance.currentPlayerCharacter)
|
|
{
|
|
baselineVelocity = (Singleton<Boat>.Instance.transform.position - lastBoatPos) / Time.fixedDeltaTime;
|
|
}
|
|
lastBoatPos = Singleton<Boat>.Instance.transform.position;
|
|
}
|
|
}
|
|
fullBodyAvatar.MovementAnimation(firstPersonController.transform.forward, firstPersonController.transform.right, velocity, baselineVelocity, firstPersonController.m_WalkSpeed, firstPersonController.m_RunSpeed);
|
|
}
|
|
|
|
private void OnEnable()
|
|
{
|
|
OnFishPicked += PickFishEvent;
|
|
FishCatchPanel.OnFishKeepGlobal += FishCatchPanel_OnFishKeepGlobal;
|
|
FishEntity.OnPreSpitOutBait += FishEntity_OnPreSpitOutBait;
|
|
FishEntityManager.AddTransformCull(base.transform);
|
|
FirstPersonController.OnJumpGlobal += FirstPersonController_OnJumpGlobal;
|
|
FirstPersonController.OnLandingGlobal += FirstPersonController_OnLandingGlobal;
|
|
}
|
|
|
|
private void OnDisable()
|
|
{
|
|
OnFishPicked -= PickFishEvent;
|
|
FishCatchPanel.OnFishKeepGlobal -= FishCatchPanel_OnFishKeepGlobal;
|
|
FishEntity.OnPreSpitOutBait -= FishEntity_OnPreSpitOutBait;
|
|
FishEntityManager.RemoveTransformCull(base.transform);
|
|
FirstPersonController.OnJumpGlobal -= FirstPersonController_OnJumpGlobal;
|
|
FirstPersonController.OnLandingGlobal -= FirstPersonController_OnLandingGlobal;
|
|
}
|
|
|
|
private void OnDestroy()
|
|
{
|
|
Singleton<SaveDataManager>.Instance.ResetRodStatuses();
|
|
}
|
|
|
|
private void FishEntity_OnPreSpitOutBait(FishEntity fish)
|
|
{
|
|
isFishCanTaken.Value = false;
|
|
fish.rod.fishingLine.currentLineHandler.EndLineRigidbody.isKinematic = false;
|
|
}
|
|
|
|
private void FirstPersonController_OnJumpGlobal(Transform t)
|
|
{
|
|
FullBodyAvatar.Jump();
|
|
}
|
|
|
|
private void FirstPersonController_OnLandingGlobal(Transform t)
|
|
{
|
|
FullBodyAvatar.Land();
|
|
}
|
|
|
|
private void PickFishHandler()
|
|
{
|
|
if (FishEntity.CurrentFishInFight == null || !isFishCanTaken.Value || FishEntity.CurrentFishInFight.IsCatched)
|
|
{
|
|
ResetTimer();
|
|
return;
|
|
}
|
|
if (InputManager.isPullUpRod)
|
|
{
|
|
fishTakeTime = Mathf.MoveTowards(fishTakeTime, fishTakeTimeTarget, Time.deltaTime);
|
|
}
|
|
else
|
|
{
|
|
ResetTimer();
|
|
}
|
|
FPlayer.OnFishPicking?.Invoke(fishTakeTime / fishTakeTimeTarget);
|
|
if (fishTakeTime == fishTakeTimeTarget)
|
|
{
|
|
ResetTimer();
|
|
FPlayer.OnFishPicked?.Invoke();
|
|
}
|
|
void ResetTimer()
|
|
{
|
|
fishTakeTime = (((bool)FishEntity.CurrentFishInFight && !FishEntity.CurrentFishInFight.IsCatched && isFishCanTaken.Value) ? 0.01f : 0f);
|
|
FPlayer.OnFishPicking?.Invoke(fishTakeTime);
|
|
}
|
|
}
|
|
|
|
private void ViewAnglerHandler()
|
|
{
|
|
if (FishEntity.CurrentFishInFight == null || FishEntity.CurrentFishInFight.Weight >= 35f || !GameManager.Instance.fishCatchPanel)
|
|
{
|
|
InputManager.isCameraChange = false;
|
|
}
|
|
else if (InputManager.isCameraChange)
|
|
{
|
|
if ((bool)currentAnglerFishView)
|
|
{
|
|
DestroyFishViewAngler();
|
|
}
|
|
else
|
|
{
|
|
ViewAngler();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void PreventWalkUnderWaterHandler()
|
|
{
|
|
Vector3 position = base.transform.position;
|
|
if (GameWaterSystem.FindWaterLevelAtLocation(position, out var waterLevel))
|
|
{
|
|
float num = waterLevel - position.y;
|
|
if (num <= -0.1f)
|
|
{
|
|
lastSafeLandPosition = position;
|
|
}
|
|
else if (!(num <= 0f))
|
|
{
|
|
base.transform.position = lastSafeLandPosition;
|
|
firstPersonController.lastValidPosition = lastSafeLandPosition;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
lastSafeLandPosition = position;
|
|
}
|
|
}
|
|
|
|
private void IsFishCanTaken_OnValueChanged(bool isCanTaken)
|
|
{
|
|
if ((bool)FishEntity.CurrentFishInFight)
|
|
{
|
|
Vector3.Distance(base.transform.position, FishEntity.CurrentFishInFight.transform.position);
|
|
}
|
|
if (handPullUp > 0f && isCanTaken && !isPickingFish && (bool)FishEntity.CurrentFishInFight)
|
|
{
|
|
isPickingFish = true;
|
|
StopCoroutine("Timer");
|
|
StartCoroutine(Timer(isPickingFish));
|
|
}
|
|
else if (!isCanTaken && isPickingFish)
|
|
{
|
|
isPickingFish = false;
|
|
StopCoroutine("Timer");
|
|
StartCoroutine(Timer(isPickingFish));
|
|
}
|
|
static IEnumerator Timer(bool isPicking)
|
|
{
|
|
if (isPicking)
|
|
{
|
|
float startTime = Time.time;
|
|
float takeTimeInterval = 3.5f;
|
|
float takeTime = startTime + takeTimeInterval;
|
|
while (Time.time < takeTime)
|
|
{
|
|
FPlayer.OnFishPicking?.Invoke((Time.time - startTime) / takeTimeInterval);
|
|
Debug.Log(">>>>>>>>>>>>>>>>>>>TRY PICK");
|
|
yield return null;
|
|
}
|
|
if ((bool)FishEntity.CurrentFishInFight)
|
|
{
|
|
FPlayer.OnFishPicked?.Invoke();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FPlayer.OnFishPicking?.Invoke(0f);
|
|
Debug.Log("NOT PICK <<<<<<<<<<<<<<<<<<<<<<");
|
|
}
|
|
}
|
|
}
|
|
|
|
public float GetCurrentGearStrength()
|
|
{
|
|
if (!currentRod)
|
|
{
|
|
return 1f;
|
|
}
|
|
if (!currentRod.currentReel)
|
|
{
|
|
return 1f;
|
|
}
|
|
if (!currentRod.currentLine)
|
|
{
|
|
return 1f;
|
|
}
|
|
float maxRodStrength = currentRod.maxRodStrength;
|
|
float maxReelStrength = currentRod.currentReel.maxReelStrength;
|
|
float strength = currentRod.currentLine.strength;
|
|
return Mathf.Min(maxRodStrength, maxReelStrength, strength);
|
|
}
|
|
|
|
private void FishCatchPanel_OnFishKeepGlobal()
|
|
{
|
|
isPickingFish = false;
|
|
currentRod.fishingLine.currentLineHandler.EndLineRigidbody.isKinematic = false;
|
|
}
|
|
|
|
private void PickFishEvent()
|
|
{
|
|
float weight = FishEntity.CurrentFishInFight.Weight;
|
|
if (weight < 1f)
|
|
{
|
|
FishConnectToLHand();
|
|
}
|
|
else if (weight < 6f)
|
|
{
|
|
FishConnectToLHandWithChwytak();
|
|
}
|
|
else if (weight < 35f)
|
|
{
|
|
FishConnectToNone();
|
|
}
|
|
else
|
|
{
|
|
FishConnectToNone();
|
|
}
|
|
}
|
|
|
|
private void BuildDestroyChwytak(bool destroy = false)
|
|
{
|
|
if (!currentChwytak && !destroy)
|
|
{
|
|
currentChwytak = UnityEngine.Object.Instantiate(FScriptsHandler.Instance.ChwytakPrefab, FullBodyAvatar.ChwytakJoiner).GetComponent<Chwytak>();
|
|
currentChwytak.transform.localPosition = Vector3.zero;
|
|
currentChwytak.transform.localEulerAngles = Vector3.zero;
|
|
currentChwytak.currentFish = FishEntity.CurrentFishInFight;
|
|
currentChwytak.currentFish.ReJoinChwytak(currentChwytak.fishJoint);
|
|
}
|
|
if ((bool)currentChwytak && destroy)
|
|
{
|
|
FullBodyAvatar.LeftArmControl(FullBodyAvatar.ArmLeft.Idle);
|
|
UnityEngine.Object.Destroy(currentChwytak.gameObject);
|
|
currentChwytak = null;
|
|
}
|
|
}
|
|
|
|
public void DestroyCurrentFish()
|
|
{
|
|
FullBodyAvatar.LeftArmControl(FullBodyAvatar.ArmLeft.Idle);
|
|
}
|
|
|
|
private void FishConnectToLHand()
|
|
{
|
|
if (FullBodyAvatar.CurrentArmLeftState != FullBodyAvatar.ArmLeft.Catch)
|
|
{
|
|
InteractiveLeftHand(null);
|
|
FullBodyAvatar.LeftArmControl(FullBodyAvatar.ArmLeft.Catch);
|
|
}
|
|
if (currentRod.fishingLine.currentLineHandler.lineType == FLineHandler.LineType.OneSegment)
|
|
{
|
|
PutLineToLeftHandHelper(currentRod.fishingLine.currentLineHandler.EndLineRigidbody.transform, FullBodyAvatar.LineJoinerFish, 3f);
|
|
}
|
|
else
|
|
{
|
|
PutLineToLeftHandHelper(currentRod.fishingLine.currentLineHandler.EndLineRigidbody.transform, FullBodyAvatar.LineJoinerFish, 3f);
|
|
}
|
|
firstPersonController.frezzePosition = true;
|
|
firstPersonController.frezzeRotation = true;
|
|
isLeftHandVisable = true;
|
|
}
|
|
|
|
private void FishConnectToLHandWithChwytak()
|
|
{
|
|
if (FullBodyAvatar.CurrentArmLeftState != FullBodyAvatar.ArmLeft.CatchChwytak)
|
|
{
|
|
InteractiveLeftHand(null);
|
|
FullBodyAvatar.LeftArmControl(FullBodyAvatar.ArmLeft.CatchChwytak);
|
|
}
|
|
if (currentRod.fishingLine.currentLineHandler.lineType == FLineHandler.LineType.OneSegment)
|
|
{
|
|
PutLineToLeftHandHelper(currentRod.fishingLine.currentLineHandler.EndLineRigidbody.transform, FullBodyAvatar.ChwytakJoiner, 4f, buildChwytak: true);
|
|
}
|
|
else
|
|
{
|
|
PutLineToLeftHandHelper(currentRod.fishingLine.currentLineHandler.EndLineRigidbody_2.transform, FullBodyAvatar.ChwytakJoiner, 4f, buildChwytak: true);
|
|
}
|
|
firstPersonController.frezzePosition = true;
|
|
firstPersonController.frezzeRotation = true;
|
|
isLeftHandVisable = true;
|
|
}
|
|
|
|
private void FishConnectToNone()
|
|
{
|
|
ViewAngler();
|
|
firstPersonController.frezzePosition = true;
|
|
firstPersonController.frezzeRotation = true;
|
|
if (!isLeftHandVisable)
|
|
{
|
|
InteractiveLeftHand(null);
|
|
}
|
|
isLeftHandVisable = true;
|
|
}
|
|
|
|
public float GetReelingForce()
|
|
{
|
|
float num = 1f;
|
|
if ((bool)currentRod && (bool)currentRod.fishingLine && (bool)FishEntity.CurrentFishInFight)
|
|
{
|
|
float num2 = Mathf.Clamp01(currentRod.fishingLine.linelenghtDiferent);
|
|
num -= 0.2f;
|
|
float num3 = Mathf.Lerp(0f, fishMaxWeightToHandsPower.Value.y, FishEntity.CurrentFishInFight.Weight / fishMaxWeightToHandsPower.Value.x);
|
|
num -= num2 * num3;
|
|
}
|
|
return Mathf.Clamp(num, 0.1f, 1f);
|
|
}
|
|
|
|
public float GetPlayerHandPower()
|
|
{
|
|
float num = 0.85f;
|
|
if ((bool)currentRod && (bool)currentRod.fishingLine)
|
|
{
|
|
float num2 = 0f;
|
|
if (Singleton<SaveDataManager>.Instance.HasCurrentPlayerSkill(GameManager.Skills.strongman_10p))
|
|
{
|
|
num2 = 0.1f;
|
|
}
|
|
else if (Singleton<SaveDataManager>.Instance.HasCurrentPlayerSkill(GameManager.Skills.strongman_5p))
|
|
{
|
|
num2 = 0.05f;
|
|
}
|
|
num += num2;
|
|
float num3 = Mathf.Clamp01(currentRod.fishingLine.linelenghtDiferent);
|
|
if (!FishEntity.CurrentFishInFight)
|
|
{
|
|
num -= num3 * 0.2f;
|
|
}
|
|
else
|
|
{
|
|
num -= 0.3f;
|
|
float num4 = Mathf.Lerp(0f, fishMaxWeightToHandsPower.Value.y, FishEntity.CurrentFishInFight.Weight / fishMaxWeightToHandsPower.Value.x);
|
|
num -= num3 * num4;
|
|
}
|
|
}
|
|
return Mathf.Clamp(num, 0.2f, 1.2f);
|
|
}
|
|
|
|
private bool CheckLineLenght()
|
|
{
|
|
float lenght = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentRod.indexOfslot].line.lenght;
|
|
float num = 0f;
|
|
if (throwMode == ThrowMode.Near)
|
|
{
|
|
float value = (0f - m_Camera.transform.localRotation.x) * 10f;
|
|
value = (3f + Mathf.Clamp(value, -2f, 0f)) * 4f;
|
|
Vector3 b = base.transform.position + base.transform.forward * value;
|
|
num = Vector3.Distance(base.transform.position, b);
|
|
}
|
|
else
|
|
{
|
|
float num2 = 0f;
|
|
if ((bool)currentRod.currentLure)
|
|
{
|
|
int indexByItemId = GameManager.Instance.GetIndexByItemId(GameManager.ItemType.Bait, currentRod.currentLure.gameID);
|
|
num2 += GameManager.Instance.gameBaits[indexByItemId].weight;
|
|
}
|
|
if ((bool)currentRod.currentWeight)
|
|
{
|
|
num2 += currentRod.currentWeight.weight;
|
|
}
|
|
Vector3 b2 = base.transform.position + base.transform.forward * ((currentRod.throwForceMaxPower + num2) * currentRod.throwPower);
|
|
num = Vector3.Distance(base.transform.position, b2);
|
|
}
|
|
Debug.Log("throwDistance: " + num);
|
|
if (num > lenght)
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private float GetMaxThrowLength()
|
|
{
|
|
float lenght = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentRod.indexOfslot].line.lenght;
|
|
float num = 0f;
|
|
if (throwMode == ThrowMode.Near)
|
|
{
|
|
float value = (0f - m_Camera.transform.localRotation.x) * 10f;
|
|
value = (3f + Mathf.Clamp(value, -2f, 0f)) * 4f;
|
|
Vector3 b = base.transform.position + base.transform.forward * value;
|
|
num = Vector3.Distance(base.transform.position, b);
|
|
}
|
|
else
|
|
{
|
|
float num2 = 0f;
|
|
if ((bool)currentRod.currentLure)
|
|
{
|
|
int indexByItemId = GameManager.Instance.GetIndexByItemId(GameManager.ItemType.Bait, currentRod.currentLure.gameID);
|
|
num2 += GameManager.Instance.gameBaits[indexByItemId].weight;
|
|
}
|
|
if ((bool)currentRod.currentWeight)
|
|
{
|
|
num2 += currentRod.currentWeight.weight;
|
|
}
|
|
Vector3 b2 = base.transform.position + base.transform.forward * ((currentRod.throwForceMaxPower + num2) * currentRod.throwPower);
|
|
num = Vector3.Distance(base.transform.position, b2);
|
|
}
|
|
return Mathf.Clamp(num, 0f, lenght);
|
|
}
|
|
|
|
private void ThrowInput()
|
|
{
|
|
if (FishEntity.CurrentFishInFight != null)
|
|
{
|
|
return;
|
|
}
|
|
if (!currentRod)
|
|
{
|
|
FScriptsHandler.Instance.m_HudManager.ShowHideThrowingBar(visable: false);
|
|
FullBodyAvatar.ReelLockUnlockReset();
|
|
FullBodyAvatar.ThrowReset();
|
|
}
|
|
if ((bool)currentRod && (bool)currentRod.currentReel && !currentRod.currentFish && !currentRod.takeFish)
|
|
{
|
|
if (InputManager.isCastFar)
|
|
{
|
|
PrepareFarThrow();
|
|
}
|
|
else
|
|
{
|
|
ThrowFar();
|
|
}
|
|
if (InputManager.isCastNear)
|
|
{
|
|
PrepareNearThrow();
|
|
}
|
|
else
|
|
{
|
|
ThrowNear();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void PrepareFarThrow()
|
|
{
|
|
if ((bool)currentRod && (bool)currentRod.currentReel && (bool)currentRod.fishingLine && !currentRod.currentReel.isHandOnHandle && !currentRod.currentReel.isBailOpen && !FullBodyAvatar.IsThrowInProgress && !(currentRod.fishingLine.currentLineHandler.PhisicsLineOut > 0f) && !(throwDelay > 0f) && !Time.timeScale.Equals(0f))
|
|
{
|
|
if (currentRod.isDamaged)
|
|
{
|
|
GameManager.Instance.ShowMessagePopup(LanguageManager.Instance.GetText("ROD_DAMAGE"), FScriptsHandler.Instance.m_Canvas.transform);
|
|
return;
|
|
}
|
|
if (currentRod.currentReel.isDamaged)
|
|
{
|
|
GameManager.Instance.ShowMessagePopup(LanguageManager.Instance.GetText("REEL_DAMAGE"), FScriptsHandler.Instance.m_Canvas.transform);
|
|
return;
|
|
}
|
|
if (!currentRod.currentLure && !currentRod.currentHook)
|
|
{
|
|
GameManager.Instance.ShowMessagePopup(LanguageManager.Instance.GetText("BAIT_ON_HOOK_EMPTY"), FScriptsHandler.Instance.m_Canvas.transform);
|
|
return;
|
|
}
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentRod.indexOfslot].status != GameManager.PlayerData.CSlots.Status.Completed)
|
|
{
|
|
GameManager.Instance.ShowMessagePopup(LanguageManager.Instance.GetText("SET_EMPTY"), FScriptsHandler.Instance.m_Canvas.transform);
|
|
return;
|
|
}
|
|
throwMode = ThrowMode.Far;
|
|
ThrowPower.Value = Mathf.Lerp(0f, 1f, Mathf.PingPong(throwTimer, 1f));
|
|
IsThrowFarPreparing.Value = true;
|
|
throwTimer += Time.deltaTime * 0.7f;
|
|
currentRod.throwPower = Mathf.Lerp(0f, 1f, Mathf.PingPong(throwTimer, 1f));
|
|
currentRod.throwPowerForSounds = currentRod.throwPower;
|
|
currentRod.isThrowing = true;
|
|
FScriptsHandler.Instance.m_HudManager.ShowHideThrowingBar(visable: true, currentRod.throwPower, currentRod.throwMinPower);
|
|
}
|
|
}
|
|
|
|
private void ThrowFar()
|
|
{
|
|
if (throwMode == ThrowMode.Far && (bool)currentRod && (bool)currentRod.fishingLine.currentLineHandler && currentRod.throwPower != 0f && !(currentRod.fishingLine.currentLineHandler.PhisicsLineOut > 0f) && !Time.timeScale.Equals(0f))
|
|
{
|
|
FScriptsHandler.Instance.m_HudManager.ShowHideThrowingBar(visable: false);
|
|
IsThrowFar.Value = true;
|
|
float num = 0f;
|
|
if ((bool)currentRod.currentLure)
|
|
{
|
|
int indexByItemId = GameManager.Instance.GetIndexByItemId(GameManager.ItemType.Bait, currentRod.currentLure.gameID);
|
|
num += GameManager.Instance.gameBaits[indexByItemId].weight;
|
|
}
|
|
if ((bool)currentRod.currentWeight)
|
|
{
|
|
num += currentRod.currentWeight.weight;
|
|
}
|
|
currentRod.throwForcePower = GetMaxThrowLength();
|
|
currentRod.throwPower = 0f;
|
|
FullBodyAvatar.Throw(FullBodyAvatar.ThrowMethod.Far);
|
|
FPlayer.OnThrowFar?.Invoke(this);
|
|
Debug.Log("Throw far Power: " + (currentRod.throwForceMaxPower + num));
|
|
throwMode = ThrowMode.None;
|
|
throwDelay = 2f;
|
|
throwTimer = 0f;
|
|
}
|
|
}
|
|
|
|
private void PrepareNearThrow()
|
|
{
|
|
if (!currentRod || !currentRod.currentReel || !currentRod.fishingLine || FullBodyAvatar.IsThrowInProgress || currentRod.currentReel.isHandOnHandle || (currentRod.fishingLine.currentLineHandler.PhisicsLineOut > 0f && throwMode == ThrowMode.None) || throwDelay > 0f)
|
|
{
|
|
return;
|
|
}
|
|
if (currentRod.isDamaged)
|
|
{
|
|
GameManager.Instance.ShowMessagePopup(LanguageManager.Instance.GetText("ROD_DAMAGE"), FScriptsHandler.Instance.m_Canvas.transform);
|
|
return;
|
|
}
|
|
if (currentRod.currentReel.isDamaged)
|
|
{
|
|
GameManager.Instance.ShowMessagePopup(LanguageManager.Instance.GetText("REEL_DAMAGE"), FScriptsHandler.Instance.m_Canvas.transform);
|
|
return;
|
|
}
|
|
if (!currentRod.currentLure && !currentRod.currentHook)
|
|
{
|
|
GameManager.Instance.ShowMessagePopup(LanguageManager.Instance.GetText("BAIT_ON_HOOK_EMPTY"), FScriptsHandler.Instance.m_Canvas.transform);
|
|
return;
|
|
}
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentRod.indexOfslot].status != GameManager.PlayerData.CSlots.Status.Completed)
|
|
{
|
|
GameManager.Instance.ShowMessagePopup(LanguageManager.Instance.GetText("SET_EMPTY"), FScriptsHandler.Instance.m_Canvas.transform);
|
|
return;
|
|
}
|
|
if (isLeftHandConnectLine)
|
|
{
|
|
throwTimer += Time.deltaTime * 0.7f;
|
|
currentRod.throwPower = Mathf.Lerp(0f, 1f, Mathf.PingPong(throwTimer, 1f));
|
|
currentRod.throwPowerForSounds = currentRod.throwPower * 0.3f;
|
|
currentRod.throwNearPower = currentRod.throwPower;
|
|
FScriptsHandler.Instance.m_HudManager.ShowHideThrowingBar(visable: true, currentRod.throwPower, currentRod.throwMinNearPower);
|
|
float value = (0f - m_Camera.transform.localRotation.x) * 10f;
|
|
value = (3f + Mathf.Clamp(value, -2f, 0f)) * 4f;
|
|
Vector3 vector = base.transform.position + base.transform.forward * value;
|
|
ShowHideNearThrowTarget(vector);
|
|
float value2 = Vector3.Distance(vector, base.transform.position) / 12f;
|
|
notValidTargetValue = FScriptsHandler.Instance.m_HudManager.currentCanvasThrowinigBar.GetComponent<CanvasThrowingBar>().SetTargetBar(value2, 1f);
|
|
}
|
|
if (!currentRod.currentReel.isBailOpen && throwMode == ThrowMode.None)
|
|
{
|
|
FullBodyAvatar.ReelControl(reelUnlock: true);
|
|
}
|
|
else if (currentRod.currentReel.isBailOpen)
|
|
{
|
|
FullBodyAvatar.LeftArmControl(FullBodyAvatar.ArmLeft.CastNear);
|
|
PutLineToLeftHandHelper(currentRod.fishingLine.currentLineHandler.LineConnector_1.transform, FullBodyAvatar.LineJoiner, 3f);
|
|
currentRod.isThrowing = true;
|
|
}
|
|
throwMode = ThrowMode.Near;
|
|
IsThrowNearPreparing.Value = true;
|
|
}
|
|
|
|
private void ThrowNear()
|
|
{
|
|
if (throwMode != ThrowMode.Near || !currentRod || !currentRod.fishingLine.currentLineHandler)
|
|
{
|
|
return;
|
|
}
|
|
FScriptsHandler.Instance.m_HudManager.ShowHideThrowingBar(visable: false);
|
|
IsThrowFar.Value = true;
|
|
if (currentRod.throwPower == 0f)
|
|
{
|
|
FullBodyAvatar.LeftArmControl(FullBodyAvatar.ArmLeft.Idle);
|
|
if (currentRod.currentReel.isBailOpen)
|
|
{
|
|
currentRod.currentReel.LockUnlockKablag();
|
|
}
|
|
OutLineFromLeftHandHelper(currentRod.fishingLine.currentLineHandler.LineConnector_1.transform);
|
|
throwMode = ThrowMode.None;
|
|
throwTimer = 0f;
|
|
currentRod.isThrowing = false;
|
|
ShowHideNearThrowTarget(Vector3.zero, isHide: true);
|
|
return;
|
|
}
|
|
if (currentRod.throwPower < currentRod.throwMinNearPower || !isLeftHandConnectLine || !CheckLineLenght())
|
|
{
|
|
if (!CheckLineLenght())
|
|
{
|
|
GameManager.Instance.ShowMessagePopup(LanguageManager.Instance.GetText("LOW_LINE_LENGHT"), FScriptsHandler.Instance.m_Canvas.transform);
|
|
}
|
|
currentRod.throwPower = 0f;
|
|
if (currentRod.currentReel.isBailOpen)
|
|
{
|
|
currentRod.currentReel.LockUnlockKablag();
|
|
}
|
|
FullBodyAvatar.LeftArmControl(FullBodyAvatar.ArmLeft.Idle);
|
|
OutLineFromLeftHandHelper(currentRod.fishingLine.currentLineHandler.LineConnector_1.transform);
|
|
throwMode = ThrowMode.None;
|
|
currentRod.isThrowing = false;
|
|
throwDelay = 2f;
|
|
ShowHideNearThrowTarget(Vector3.zero, isHide: true);
|
|
return;
|
|
}
|
|
float num = 0f;
|
|
if ((bool)currentRod.currentLure)
|
|
{
|
|
int indexByItemId = GameManager.Instance.GetIndexByItemId(GameManager.ItemType.Bait, currentRod.currentLure.gameID);
|
|
num += GameManager.Instance.gameBaits[indexByItemId].weight;
|
|
}
|
|
if ((bool)currentRod.currentWeight)
|
|
{
|
|
num += currentRod.currentWeight.weight;
|
|
}
|
|
currentRod.throwForcePower = (currentRod.throwForceMaxNearPower + num) * currentRod.throwPower;
|
|
currentRod.throwPower = 0f;
|
|
Debug.Log("Throw near Power: " + (currentRod.throwForceMaxNearPower + num));
|
|
FullBodyAvatar.Throw(FullBodyAvatar.ThrowMethod.Near);
|
|
FullBodyAvatar.LeftArmControl(FullBodyAvatar.ArmLeft.Idle);
|
|
FPlayer.OnThrowNear?.Invoke(this);
|
|
throwMode = ThrowMode.None;
|
|
throwDelay = 2f;
|
|
throwTimer = 0f;
|
|
}
|
|
|
|
public void ShowHideNearThrowTarget(Vector3 targetPosition, bool isHide = false)
|
|
{
|
|
if (isHide && !currentNearThrowTarget)
|
|
{
|
|
return;
|
|
}
|
|
if ((bool)currentNearThrowTarget)
|
|
{
|
|
if (isHide)
|
|
{
|
|
UnityEngine.Object.Destroy(currentNearThrowTarget.gameObject);
|
|
return;
|
|
}
|
|
GameWaterSystem.FindWaterLevelAtLocation(targetPosition, out var waterLevel);
|
|
targetPosition.y = waterLevel;
|
|
currentNearThrowTarget.position = targetPosition;
|
|
}
|
|
else
|
|
{
|
|
currentNearThrowTarget = UnityEngine.Object.Instantiate(FScriptsHandler.Instance.nearThrowTargetPrefab, FScriptsHandler.Instance.transform).GetComponent<Transform>();
|
|
}
|
|
}
|
|
|
|
private void PutLineToLeftHandHelper(Transform connector, Transform lHandPoint, float speed = 1f, bool buildChwytak = false)
|
|
{
|
|
connector.GetComponent<Rigidbody>().isKinematic = true;
|
|
isLeftHandConnectLine = false;
|
|
connector.position = Vector3.MoveTowards(connector.position, lHandPoint.position, Time.deltaTime * speed);
|
|
currentRod.fishingLine.currentLineHandler.PhisicsLineOut = Vector3.Distance(connector.position, currentRod.fishingLine.currentLineHandler.LineConnector_0.transform.position) * 0.5f;
|
|
if ((bool)FishEntity.CurrentFishInFight)
|
|
{
|
|
FishEntity.CurrentFishInFight.Physics.Rbody.useGravity = false;
|
|
}
|
|
if ((bool)FishEntity.CurrentFishInFight && currentRod.fishingLine.currentLineHandler.lineType == FLineHandler.LineType.TwoSegment)
|
|
{
|
|
Rigidbody endLineRigidbody_ = currentRod.fishingLine.currentLineHandler.EndLineRigidbody_1;
|
|
endLineRigidbody_.isKinematic = true;
|
|
endLineRigidbody_.position = Vector3.MoveTowards(endLineRigidbody_.position, lHandPoint.position, Time.deltaTime * speed);
|
|
}
|
|
if (buildChwytak)
|
|
{
|
|
BuildDestroyChwytak();
|
|
}
|
|
Transform parent = (currentChwytak ? currentChwytak.fishJoint.transform : lHandPoint);
|
|
currentRod.fishingLine.currentLineHandler.transform.SetParent(currentRod.transform);
|
|
currentRod.fishingLine.currentLineHandler.transform.localPosition = Vector3.zero;
|
|
connector.SetParent(parent);
|
|
connector.localPosition = Vector3.zero;
|
|
currentRod.fishingLine.currentLineHandler.PhisicsLineOut = Vector3.Distance(connector.position, currentRod.fishingLine.currentLineHandler.LineConnector_0.transform.position);
|
|
isLeftHandConnectLine = true;
|
|
if ((bool)FishEntity.CurrentFishInFight)
|
|
{
|
|
FishEntity.CurrentFishInFight.Physics.Rbody.useGravity = true;
|
|
if ((bool)FishEntity.CurrentFishInFight.Physics.Collider)
|
|
{
|
|
FishEntity.CurrentFishInFight.Physics.Collider.enabled = true;
|
|
}
|
|
if (currentRod.fishingLine.currentLineHandler.lineType == FLineHandler.LineType.TwoSegment)
|
|
{
|
|
Rigidbody endLineRigidbody_2 = currentRod.fishingLine.currentLineHandler.EndLineRigidbody_1;
|
|
endLineRigidbody_2.transform.SetParent(parent);
|
|
endLineRigidbody_2.transform.localPosition = Vector3.zero;
|
|
currentRod.currentFloat.transform.position = endLineRigidbody_2.position;
|
|
currentRod.currentFloat.rigidbody.velocity = Vector3.zero;
|
|
currentRod.currentFloat.rigidbody.angularVelocity = Vector3.zero;
|
|
currentRod.currentFloat.rigidbody.useGravity = true;
|
|
endLineRigidbody_2.isKinematic = false;
|
|
}
|
|
FullBodyAvatar.LookAtFishInHand();
|
|
}
|
|
}
|
|
|
|
public void OutLineFromLeftHandHelper(Transform connector)
|
|
{
|
|
connector.GetComponent<Rigidbody>().isKinematic = false;
|
|
currentRod.fishingLine.currentLineHandler.transform.SetParent(currentRod.fishingLine.obiFixedUpdater.transform);
|
|
currentRod.fishingLine.currentLineHandler.transform.localEulerAngles = Vector3.zero;
|
|
connector.transform.SetParent(currentRod.fishingLine.currentLineHandler.transform);
|
|
currentRod.fishingLine.currentLineHandler.PhisicsLineOut = 0f;
|
|
isLeftHandConnectLine = false;
|
|
if (currentRod.fishingLine.currentLineHandler.lineType == FLineHandler.LineType.TwoSegment)
|
|
{
|
|
currentRod.fishingLine.currentLineHandler.EndLineRigidbody_1.transform.SetParent(currentRod.fishingLine.currentLineHandler.transform);
|
|
}
|
|
BuildDestroyChwytak(destroy: true);
|
|
}
|
|
|
|
public void UnlockLockReel()
|
|
{
|
|
if (!currentRod.currentReel.isBailOpen)
|
|
{
|
|
FullBodyAvatar.ReelControl(reelUnlock: true);
|
|
}
|
|
else
|
|
{
|
|
FullBodyAvatar.ReelControl(reelUnlock: false, reelLock: true);
|
|
}
|
|
}
|
|
|
|
private void CheckAndConnectRod()
|
|
{
|
|
if ((bool)assignRod && !(assignRod == currentRod))
|
|
{
|
|
if ((bool)currentRod)
|
|
{
|
|
currentRod.transform.SetParent(base.transform.parent);
|
|
currentRod.GetComponent<BoxCollider>().enabled = true;
|
|
currentRod = null;
|
|
}
|
|
currentRod = assignRod;
|
|
assignRod = null;
|
|
currentRod.GetComponent<BoxCollider>().enabled = false;
|
|
currentRod.GetComponent<Rigidbody>().isKinematic = true;
|
|
currentRod.transform.SetParent(fullBodyAvatar.RodJoiner);
|
|
currentRod.transform.localPosition = Vector3.zero;
|
|
currentRod.transform.rotation = fullBodyAvatar.RodJoiner.rotation;
|
|
currentRod.currentPlayer = this;
|
|
}
|
|
}
|
|
|
|
private void UnderWaterCameraControler()
|
|
{
|
|
if (currentRod == null && (bool)underWaterCamera)
|
|
{
|
|
DestroyUnderwaterCamera();
|
|
}
|
|
else
|
|
{
|
|
if (currentRod == null || !currentRod.fishingLine || !currentRod.fishingLine.currentLineHandler || currentRod.isThrowing || GameManager.Instance.addectiveSceneLoading || GameManager.Instance.addectiveSceneLoaded != "none" || Singleton<GameCameraController>.Instance.IsCameraZoomIn || (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().GameMode == GameManager.PlayerData.CPlayer.GameMode.Realistic && !GameManager.Instance.isDevModeAllowed) || Time.timeScale == 0f)
|
|
{
|
|
return;
|
|
}
|
|
if (currentRod.fishingLine.currentLineHandler.PhisicsLineOut < 1f)
|
|
{
|
|
if (underWaterCamera != null)
|
|
{
|
|
DestroyUnderwaterCamera();
|
|
}
|
|
return;
|
|
}
|
|
if ((bool)currentRod.LureHookWaterDisplacement)
|
|
{
|
|
GameWaterSystem.FindWaterLevelAtLocation(currentRod.LureHookWaterDisplacement.transform.position, out var waterLevel);
|
|
if (currentRod.LureHookWaterDisplacement.transform.position.y > waterLevel + 0.2f && !currentRod.currentFish)
|
|
{
|
|
if (underWaterCamera != null)
|
|
{
|
|
DestroyUnderwaterCamera();
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
if (InputManager.isUnderwaterCamera)
|
|
{
|
|
if (underWaterCamera == null && currentRod.LureHookWaterDisplacement.IsInWater)
|
|
{
|
|
underWaterCamera = UnityEngine.Object.Instantiate(FScriptsHandler.Instance.underWaterCameraPrefab, FScriptsHandler.Instance.transform);
|
|
underWaterCamera.GetComponent<SmoothFollowUnderwater>().currentRod = currentRod;
|
|
(currentCameraView = Camera.main).rect = new Rect(0f, 0f, 1f, 1f);
|
|
firstPersonController.enabled = false;
|
|
FullBodyAvatar.ShowHead();
|
|
FPlayer.OnChangeCameraToUnderwater?.Invoke();
|
|
}
|
|
}
|
|
else if (underWaterCamera != null)
|
|
{
|
|
DestroyUnderwaterCamera();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void DestroyUnderwaterCamera()
|
|
{
|
|
firstPersonController.enabled = true;
|
|
currentCameraView = m_Camera;
|
|
UnityEngine.Object.Destroy(underWaterCamera.gameObject);
|
|
underWaterCamera = null;
|
|
InputManager.isUnderwaterCamera = false;
|
|
FullBodyAvatar.ShowHead(toggle: false);
|
|
SetGpuInstancerCamera(m_Camera);
|
|
FPlayer.OnChangeCameraOutUnderwater?.Invoke();
|
|
}
|
|
|
|
private IEnumerator SetGpuInstancerCamera(Camera newCam)
|
|
{
|
|
yield return null;
|
|
GPUInstancerTreeManager gPUInstancerTreeManager = UnityEngine.Object.FindObjectOfType<GPUInstancerTreeManager>();
|
|
if ((bool)gPUInstancerTreeManager)
|
|
{
|
|
gPUInstancerTreeManager.SetCamera(newCam);
|
|
}
|
|
GPUInstancerDetailManager gPUInstancerDetailManager = UnityEngine.Object.FindObjectOfType<GPUInstancerDetailManager>();
|
|
if ((bool)gPUInstancerDetailManager)
|
|
{
|
|
gPUInstancerDetailManager.SetCamera(newCam);
|
|
}
|
|
}
|
|
|
|
public void SetMouseCursor(bool visable)
|
|
{
|
|
m_MouseLook.SetCursorLock(visable);
|
|
m_MouseLook.UpdateCursorLock();
|
|
}
|
|
|
|
public void SpawnPlayer(Transform newPosition)
|
|
{
|
|
Debug.Log("Spawn to: " + newPosition.position.ToString());
|
|
base.transform.position = newPosition.position;
|
|
firstPersonController.lastValidPosition = newPosition.position;
|
|
base.transform.localEulerAngles = newPosition.localEulerAngles;
|
|
if ((bool)currentRod)
|
|
{
|
|
if ((bool)currentRod.fishingLine.currentLineHandler.EndLineRigidbody_1)
|
|
{
|
|
currentRod.fishingLine.currentLineHandler.EndLineRigidbody_1.position = base.transform.position;
|
|
}
|
|
if ((bool)currentRod.fishingLine.currentLineHandler.EndLineRigidbody_2)
|
|
{
|
|
currentRod.fishingLine.currentLineHandler.EndLineRigidbody_2.position = base.transform.position;
|
|
}
|
|
if ((bool)currentRod.fishingLine.currentLineHandler.EndLineRigidbody_3)
|
|
{
|
|
currentRod.fishingLine.currentLineHandler.EndLineRigidbody_3.position = base.transform.position;
|
|
}
|
|
if ((bool)currentRod.currentFloat)
|
|
{
|
|
currentRod.currentFloat.transform.position = currentRod.fishingLine.currentLineHandler.EndLineRigidbody_1.position;
|
|
}
|
|
if ((bool)currentRod.currentHook)
|
|
{
|
|
currentRod.currentHook.transform.position = currentRod.fishingLine.currentLineHandler.EndLineRigidbody_2.position;
|
|
}
|
|
if ((bool)currentRod.currentLure)
|
|
{
|
|
currentRod.currentLure.transform.position = currentRod.fishingLine.currentLineHandler.EndLineRigidbody_1.position;
|
|
}
|
|
if ((bool)currentRod.currentFeeder)
|
|
{
|
|
currentRod.currentFeeder.transform.position = currentRod.fishingLine.currentLineHandler.EndLineRigidbody_3.position;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ShowAnglerFishView(GameManager.FishSpecies fishSpecies, float fishWeight)
|
|
{
|
|
if (!currentAnglerFishView)
|
|
{
|
|
GameObject original = FScriptsHandler.Instance.fishAnglerViewPrefab[3];
|
|
currentAnglerFishView = UnityEngine.Object.Instantiate(original, base.transform.position, base.transform.rotation, base.transform.parent).GetComponent<AnglerViewFish>();
|
|
currentAnglerFishView.transform.position = new Vector3(base.transform.position.x, base.transform.position.y - characterController.height / 2f, base.transform.position.z);
|
|
currentAnglerFishView.currentFish = FishEntity.CurrentFishInFight;
|
|
FullBodyAvatar.ShowHead();
|
|
if (FishEntity.CurrentFishInFight.Weight >= 6f)
|
|
{
|
|
ToggleRodVisibility(setEnable: false);
|
|
}
|
|
InputManager.isCameraChange = false;
|
|
}
|
|
}
|
|
|
|
public void DestroyFishViewAngler(bool fromPanel = false)
|
|
{
|
|
if ((bool)currentAnglerFishView && (!FishEntity.CurrentFishInFight || !(FishEntity.CurrentFishInFight.Weight >= 35f) || fromPanel))
|
|
{
|
|
UnityEngine.Object.Destroy(currentAnglerFishView.gameObject);
|
|
currentAnglerFishView = null;
|
|
FullBodyAvatar.ShowHead(toggle: false);
|
|
ToggleRodVisibility(setEnable: true);
|
|
currentRod.currentHook?.ShowRenderer();
|
|
currentRod.currentLure?.ShowRenderer();
|
|
InputManager.isCameraChange = false;
|
|
}
|
|
}
|
|
|
|
private void RandomizeSpawnPointInMultiplayer()
|
|
{
|
|
if (MultiplayerManager.InRoomLocationStatic)
|
|
{
|
|
Vector2 vector = new Vector2(0.5f, 3f);
|
|
Vector2 vector2 = new Vector2(1f, 1f);
|
|
float y = UnityEngine.Random.Range(vector.x, vector.y);
|
|
Vector2 vector3 = UnityEngine.Random.insideUnitCircle.normalized * UnityEngine.Random.Range(vector2.x, vector2.y);
|
|
base.transform.position += new Vector3(vector3.x, y, vector3.y);
|
|
}
|
|
}
|
|
|
|
private void DetectWaterStep()
|
|
{
|
|
delayStepSplash = Mathf.MoveTowards(delayStepSplash, 0f, Time.deltaTime);
|
|
if (delayStepSplash > 0f || !firstPersonController.isWater || !(firstPersonController.m_Input != Vector2.zero))
|
|
{
|
|
return;
|
|
}
|
|
splashStepList.RemoveAll((GameObject element) => element == null);
|
|
if (splashStepList.Count < 10)
|
|
{
|
|
GameWaterSystem.FindWaterLevelAtLocation(base.transform.position, out var waterLevel);
|
|
Vector3 position = new Vector3(base.transform.position.x, waterLevel + 0.1f, base.transform.position.z) + base.transform.forward * 0.1f;
|
|
if (firstPersonController.m_Input.y > 0f)
|
|
{
|
|
position = new Vector3(base.transform.position.x, waterLevel + 0.1f, base.transform.position.z) + base.transform.forward * 0.6f;
|
|
}
|
|
GameObject gameObject = UnityEngine.Object.Instantiate(FScriptsHandler.Instance.waterFishSplash[3], position, Quaternion.identity);
|
|
gameObject.transform.localScale = Vector3.one * UnityEngine.Random.Range(0.05f, 0.3f);
|
|
splashStepList.Add(gameObject);
|
|
delayStepSplash = 0.5f;
|
|
}
|
|
}
|
|
|
|
public void ThrowNearAnimationEvent()
|
|
{
|
|
OutLineFromLeftHandHelper(currentRod.fishingLine.currentLineHandler.LineConnector_1.transform);
|
|
}
|
|
|
|
private void ToggleRodVisibility(bool setEnable)
|
|
{
|
|
if (currentRod == null)
|
|
{
|
|
return;
|
|
}
|
|
if (currentRodInHand == null || currentRodInHand != currentRod)
|
|
{
|
|
currentRodInHand = currentRod;
|
|
currentRodRenderers = new Dictionary<Renderer, bool>();
|
|
AddRenderers(currentRodInHand);
|
|
AddRenderers(currentRodInHand.currentLure);
|
|
AddRenderers(currentRodInHand.currentFloat);
|
|
AddRenderers(currentRodInHand.currentHook);
|
|
AddRenderers(currentRodInHand.currentFeeder);
|
|
AddRenderers(currentRodInHand.currentBait);
|
|
AddRenderers(currentRodInHand.currentLine);
|
|
AddRenderers(currentRodInHand.currentWeight);
|
|
}
|
|
foreach (KeyValuePair<Renderer, bool> currentRodRenderer in currentRodRenderers)
|
|
{
|
|
currentRodRenderer.Key.enabled = setEnable && currentRodRenderer.Value;
|
|
}
|
|
currentRodInHand.fishingLine.currentLineHandler.ToggleLineVisibility(setEnable);
|
|
void AddRenderers(MonoBehaviour rodEquipment)
|
|
{
|
|
if (rodEquipment == null)
|
|
{
|
|
return;
|
|
}
|
|
foreach (Renderer item in rodEquipment.gameObject.GetComponentsInChildren<Renderer>().ToList())
|
|
{
|
|
if (!currentRodRenderers.ContainsKey(item))
|
|
{
|
|
currentRodRenderers.Add(item, item.enabled);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void HandsAnimation()
|
|
{
|
|
if (!currentRod)
|
|
{
|
|
FullBodyAvatar.HandsIdle();
|
|
}
|
|
else
|
|
{
|
|
if (!currentRod.currentReel)
|
|
{
|
|
return;
|
|
}
|
|
if (!FishEntity.CurrentFishInFight && isLeftHandVisable)
|
|
{
|
|
isLeftHandVisable = false;
|
|
OutLineFromLeftHandHelper(currentRod.fishingLine.currentLineHandler.EndLineRigidbody.transform);
|
|
}
|
|
bool flag = FullBodyAvatar.CurrentArmLeftState == FullBodyAvatar.ArmLeft.IK;
|
|
FishEntity currentFishInFight = FishEntity.CurrentFishInFight;
|
|
if ((bool)currentFishInFight)
|
|
{
|
|
FullBodyAvatar.SetFishOnRod(FullBodyAvatar.FishOnRod.Hook);
|
|
}
|
|
else
|
|
{
|
|
FullBodyAvatar.SetFishOnRod(FullBodyAvatar.FishOnRod.None);
|
|
}
|
|
if (currentRod.currentReel.isHandOnHandle)
|
|
{
|
|
FullBodyAvatar.SetFingersLeft(FullBodyAvatar.FingersLeft.OnReelHandle);
|
|
}
|
|
else
|
|
{
|
|
FullBodyAvatar.SetFingersLeft(FullBodyAvatar.FingersLeft.Idle);
|
|
}
|
|
if (InputManager.isPullUpRod)
|
|
{
|
|
FullBodyAvatar.SetFingersRight(FullBodyAvatar.FingersRight.OnRodTight);
|
|
}
|
|
else
|
|
{
|
|
FullBodyAvatar.SetFingersRight(FullBodyAvatar.FingersRight.OnRodLoose);
|
|
}
|
|
float num = GetPlayerHandPower();
|
|
if ((bool)currentFishInFight && !currentFishInFight.IsHooked)
|
|
{
|
|
num = 7f;
|
|
if (handPullUp >= 0.3f)
|
|
{
|
|
currentFishInFight.IsHooked = true;
|
|
FPlayer.OnRodJam?.Invoke(this);
|
|
}
|
|
}
|
|
float num2 = (InputManager.isPullUpRod ? 1f : 0f);
|
|
float a = 0f;
|
|
float num3 = Vector3.Distance(currentRod.fishingLine.currentLineHandler.EndLineRigidbody.transform.position, base.transform.position);
|
|
if (!currentRod.isThrowing && currentRod.fishingLine.currentLineHandler.PhisicsLineOut > 1f && num3 > 5f)
|
|
{
|
|
Vector3 vector = currentRod.fishingLine.currentLineHandler.EndLineRigidbody.transform.position - base.transform.position;
|
|
vector.y = 0f;
|
|
vector.Normalize();
|
|
Vector3 forward = base.transform.forward;
|
|
forward.y = 0f;
|
|
forward.Normalize();
|
|
a = Mathf.Clamp(Vector3.SignedAngle(vector, forward, Vector3.up) / 45f, -1f, 1f);
|
|
}
|
|
float num4 = 0f;
|
|
if (flag)
|
|
{
|
|
if (CameraPivot.localEulerAngles.x < 180f)
|
|
{
|
|
num4 = Mathf.InverseLerp(0f, firstPersonController.m_MouseLook.MaximumX, CameraPivot.localEulerAngles.x);
|
|
num4 *= -1f;
|
|
}
|
|
else
|
|
{
|
|
num4 = Mathf.InverseLerp(0f, 0f - firstPersonController.m_MouseLook.MinimumX, 360f - CameraPivot.localEulerAngles.x);
|
|
}
|
|
}
|
|
float num5 = 0.7f;
|
|
num5 = ((!(num4 > 0f)) ? Mathf.Lerp(0.7f, 0.3f, 0f - num4) : Mathf.Lerp(0.7f, 0.2f, num4));
|
|
num2 *= num5;
|
|
a = Mathf.Lerp(a, 0f, num2 * 0.4f);
|
|
num4 += 0.2f;
|
|
if (isFishCanTaken.Value)
|
|
{
|
|
num2 = fishTakeTime / fishTakeTimeTarget * 0.5f;
|
|
a = 0f;
|
|
num4 = 0f;
|
|
}
|
|
float maxDelta = ((num2 == 0f) ? Time.deltaTime : (Time.deltaTime * num));
|
|
handPullUp = Mathf.MoveTowards(handPullUp, num2, maxDelta);
|
|
rotRodLeftRight = Mathf.MoveTowards(rotRodLeftRight, a, Time.deltaTime * 2f);
|
|
if (num4 > rotRodUpDown)
|
|
{
|
|
rotRodUpDown = Mathf.MoveTowards(rotRodUpDown, num4, Time.deltaTime * num * 3f);
|
|
}
|
|
else
|
|
{
|
|
rotRodUpDown = Mathf.MoveTowards(rotRodUpDown, num4, Time.deltaTime * 3f);
|
|
}
|
|
FullBodyAvatar.RodPullUp(handPullUp, flag ? 1f : 0f);
|
|
FullBodyAvatar.RodAngle(rotRodLeftRight, rotRodUpDown, flag ? 1f : 0f, flag ? 1f : 0f);
|
|
}
|
|
}
|
|
|
|
public void InteractiveLeftHand(Transform interactiveObject)
|
|
{
|
|
if (interactiveObject == null)
|
|
{
|
|
FullBodyAvatar.LeftArmControl(FullBodyAvatar.ArmLeft.Idle);
|
|
if ((bool)currentRod && (bool)currentRod.currentReel)
|
|
{
|
|
currentRod.currentReel.isHandOnHandle = false;
|
|
}
|
|
return;
|
|
}
|
|
string text = interactiveObject.tag;
|
|
if (!(text == "Reel"))
|
|
{
|
|
if (text == "ReelUnlock")
|
|
{
|
|
FullBodyAvatar.LeftArmControl(FullBodyAvatar.ArmLeft.IK, currentRod.currentReel.BailHandle);
|
|
if ((bool)currentRod && (bool)currentRod.currentReel)
|
|
{
|
|
currentRod.currentReel.isHandOnHandle = false;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FullBodyAvatar.LeftArmControl(FullBodyAvatar.ArmLeft.IK, currentRod.currentReel.handle);
|
|
if ((bool)currentRod && (bool)currentRod.currentReel)
|
|
{
|
|
currentRod.currentReel.isHandOnHandle = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ViewAngler()
|
|
{
|
|
if ((bool)FishEntity.CurrentFishInFight)
|
|
{
|
|
ShowAnglerFishView(FishEntity.CurrentFishInFight.Data.Species, FishEntity.CurrentFishInFight.Weight);
|
|
}
|
|
}
|
|
|
|
private void FlashlightHandler()
|
|
{
|
|
if (InputManager.isHeadFlashLight)
|
|
{
|
|
if (Singleton<ChatManager>.Instance != null && (!Singleton<ChatManager>.Instance.IsChatOpen || Time.timeScale == 0f) && !flashLight.activeSelf)
|
|
{
|
|
flashLight.SetActive(value: true);
|
|
}
|
|
}
|
|
else if (flashLight.activeSelf)
|
|
{
|
|
flashLight.SetActive(value: false);
|
|
}
|
|
}
|
|
}
|