1238 lines
34 KiB
C#
1238 lines
34 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using BitStrap;
|
|
using UltimateWater;
|
|
using UnityEngine;
|
|
|
|
public class BoatSimulator : MonoBehaviour
|
|
{
|
|
public enum BoatState
|
|
{
|
|
IDLE = 0,
|
|
PLAYER_FISHING = 1,
|
|
PLAYER_DRIVING = 2
|
|
}
|
|
|
|
[ReadOnly]
|
|
public BoatState currentState;
|
|
|
|
public Transform enterPosition;
|
|
|
|
public Transform enterPositionVR;
|
|
|
|
public Transform exitPosition;
|
|
|
|
public Transform startPosition;
|
|
|
|
public Transform returnPosition;
|
|
|
|
public Transform fishingPosition;
|
|
|
|
public List<GameObject> turnOffWhileDriving = new List<GameObject>();
|
|
|
|
public List<GameObject> turnOffWhileKeepMoving = new List<GameObject>();
|
|
|
|
[Space(10f)]
|
|
public BoatGauge gaugeSpeed;
|
|
|
|
public BoatGauge gaugeFuel;
|
|
|
|
public BoatGauge gaugeDirection;
|
|
|
|
[Space(10f)]
|
|
public Transform watchFishPosition;
|
|
|
|
public Transform watchPlayerPosition;
|
|
|
|
public bool watchFishOnSide;
|
|
|
|
public float netSitDownHeight = -1f;
|
|
|
|
public RodStand rodStand;
|
|
|
|
public bool permanentRodStand;
|
|
|
|
[Space(10f)]
|
|
public BoatInteractive interactiveEnter;
|
|
|
|
public BoatInteractive interactiveExit;
|
|
|
|
public BoatInteractive interactiveDriveStart;
|
|
|
|
public BoatInteractive interactiveDriveStop;
|
|
|
|
[ReadOnly]
|
|
public WaterVolumeSubtract waterVolumeSubstract;
|
|
|
|
public Transform fishScareCollider;
|
|
|
|
[Space(10f)]
|
|
public GameObject modelParent;
|
|
|
|
public GameObject paddles;
|
|
|
|
public GameObject propeller;
|
|
|
|
public float propellerSpeed = 100f;
|
|
|
|
public GameObject steeringWheel;
|
|
|
|
public float wheelRotationSpeed = 10f;
|
|
|
|
public float maxWheelRotationF = 180f;
|
|
|
|
[ReadOnly]
|
|
public float currentWheelRotation;
|
|
|
|
[ReadOnly]
|
|
public float currentWheelFactor;
|
|
|
|
[Space(10f)]
|
|
public Transform forcePosition;
|
|
|
|
public Vector3 rotateVector = Vector3.zero;
|
|
|
|
public float forwardForce = 500f;
|
|
|
|
public float backwardForce = 500f;
|
|
|
|
public float turnForce = 100f;
|
|
|
|
public float trollingForceMultiplier = 0.5f;
|
|
|
|
public float minFishTrollingSpeed = 2.5f;
|
|
|
|
[ReadOnly]
|
|
public bool keepMovingForward;
|
|
|
|
public Vector2 dragIdle = Vector2.one;
|
|
|
|
public Vector2 dragEngine = Vector2.one;
|
|
|
|
[Space(10f)]
|
|
public string engineSound = string.Empty;
|
|
|
|
public string waterSound = string.Empty;
|
|
|
|
public string collisionDefaultSound = string.Empty;
|
|
|
|
public string collisionTerrainSound = string.Empty;
|
|
|
|
public string engineIdleSound = string.Empty;
|
|
|
|
public string engineStartSound = string.Empty;
|
|
|
|
public string engineStopSound = string.Empty;
|
|
|
|
[ReadOnly]
|
|
public float collisionSoundTimer;
|
|
|
|
[HideInInspector]
|
|
public AudioObject engineAudioObject;
|
|
|
|
[HideInInspector]
|
|
public AudioObject engineIdleAudioObject;
|
|
|
|
[HideInInspector]
|
|
public AudioObject waterAudioObject;
|
|
|
|
public Vector2 engineVolume = new Vector2(0f, 1f);
|
|
|
|
public Vector2 enginePitch = new Vector2(0.5f, 1.1f);
|
|
|
|
public Vector2 waterVolume = new Vector2(0f, 1f);
|
|
|
|
public float trollingEngineSoundVolume = 0.5f;
|
|
|
|
[ReadOnly]
|
|
public float engineForce;
|
|
|
|
public float engineForceSpeed = 0.1f;
|
|
|
|
[Space(10f)]
|
|
public bool changePlayerParent = true;
|
|
|
|
public bool freezeRotation = true;
|
|
|
|
public bool isKayak;
|
|
|
|
public float kayakSitHeight = 1.3f;
|
|
|
|
[HideInInspector]
|
|
public Rigidbody myRigidbody;
|
|
|
|
private bool keyPressedW;
|
|
|
|
private bool keyPressedA;
|
|
|
|
private bool keyPressedS;
|
|
|
|
private bool keyPressedD;
|
|
|
|
[ReadOnly]
|
|
public float noTurningTimer;
|
|
|
|
public List<ParticleEmitter> waterEmitters = new List<ParticleEmitter>();
|
|
|
|
public List<GameObject> waterEffects = new List<GameObject>();
|
|
|
|
[HideInInspector]
|
|
public List<ParticleSystem> waterSplashEffects = new List<ParticleSystem>();
|
|
|
|
public List<GameObject> waterSplashEffectsPos = new List<GameObject>();
|
|
|
|
private float waterSplashTimer = 5f;
|
|
|
|
private float waterSplashSmallTimer = 2f;
|
|
|
|
public float wakeEffectSpeed = 1f;
|
|
|
|
public float blurFactor = 1f;
|
|
|
|
public float speedFxThreshold = 30f;
|
|
|
|
[ReadOnly]
|
|
public float currentSpeedFx;
|
|
|
|
[Header("Waves")]
|
|
public bool pauseFloating;
|
|
|
|
public Transform objectsParent;
|
|
|
|
public Transform engineParent;
|
|
|
|
public float engineParentMaxRotationX = 2f;
|
|
|
|
public Vector2 engineParentMaxRotationZ = new Vector2(5f, 5f);
|
|
|
|
public Vector3 engineParentRotationSpeed = Vector3.one;
|
|
|
|
private Vector3 engineParentPrevRotation = Vector3.zero;
|
|
|
|
public Transform centerParent;
|
|
|
|
private Vector3 floatingCurrent = Vector3.zero;
|
|
|
|
private Vector3 floatingTarget = Vector3.one;
|
|
|
|
public float floatingTargetMultiplier = 1f;
|
|
|
|
private Vector3 floatingPrevTarget = Vector3.zero;
|
|
|
|
private Vector3 floatingSpeed = Vector3.one;
|
|
|
|
public float floatingSpeedMultiplier = 2f;
|
|
|
|
public AnimationCurve floatingLerpCurve = AnimationCurve.EaseInOut(0f, 0f, 1f, 1f);
|
|
|
|
public AnimationCurve rotateLerpCurve = AnimationCurve.EaseInOut(0f, 0f, 1f, 1f);
|
|
|
|
[ReadOnly]
|
|
public FishPartAnim animPosY;
|
|
|
|
public float animPosYMaxMultiplier = 1f;
|
|
|
|
public Vector2 animPosYDuration = new Vector2(0.3f, 2f);
|
|
|
|
[Space(10f)]
|
|
public float centerParentMoveYMax = 0.5f;
|
|
|
|
public float centerParentRotXMax = 2f;
|
|
|
|
public float centerParentRotXSpeed = 7f;
|
|
|
|
public float centerParentRotZMax = 1f;
|
|
|
|
public float centerParentRotZSpeed = 8f;
|
|
|
|
[HideInInspector]
|
|
public FishingPlayer fishingPlayer;
|
|
|
|
[ReadOnly]
|
|
public bool initialized;
|
|
|
|
[Header("Player")]
|
|
public Vector2 playerForwardMoveMax = new Vector2(-0.3f, 0.1f);
|
|
|
|
public Vector2 playerForwardMoveSpeed = new Vector2(1f, 1f);
|
|
|
|
public float playerSideRotateMax = 15f;
|
|
|
|
public float playerSideRotateSpeed = 1f;
|
|
|
|
public float playerDownRotateMax = 15f;
|
|
|
|
public Vector3 playerCurrentMove = Vector3.zero;
|
|
|
|
public Vector3 playerCurrentRotation = Vector3.zero;
|
|
|
|
public bool showCameraDrops = true;
|
|
|
|
[Space(10f)]
|
|
public VRBoatWheel vrBoatWheel;
|
|
|
|
public float vrBoatWheelPow = 2f;
|
|
|
|
public List<GameObject> allMovingPlatforms = new List<GameObject>();
|
|
|
|
private void Awake()
|
|
{
|
|
if ((bool)FisheryEditor.Instance)
|
|
{
|
|
foreach (GameObject waterEffect in waterEffects)
|
|
{
|
|
waterEffect.SetActive(false);
|
|
}
|
|
if ((bool)fishScareCollider)
|
|
{
|
|
fishScareCollider.gameObject.SetActive(false);
|
|
}
|
|
Collider[] components = GetComponents<Collider>();
|
|
Collider[] array = components;
|
|
foreach (Collider collider in array)
|
|
{
|
|
collider.isTrigger = true;
|
|
}
|
|
Collider[] componentsInChildren = GetComponentsInChildren<Collider>();
|
|
Collider[] array2 = componentsInChildren;
|
|
foreach (Collider collider2 in array2)
|
|
{
|
|
collider2.gameObject.SetActive(false);
|
|
collider2.gameObject.SetActive(true);
|
|
collider2.enabled = false;
|
|
}
|
|
}
|
|
if ((bool)FisheryEditor.Instance)
|
|
{
|
|
return;
|
|
}
|
|
myRigidbody = GetComponent<Rigidbody>();
|
|
if (VRManager.IsVROn() && (bool)enterPositionVR)
|
|
{
|
|
enterPosition.position = enterPositionVR.position;
|
|
enterPosition.rotation = enterPositionVR.rotation;
|
|
}
|
|
if ((bool)centerParent)
|
|
{
|
|
objectsParent.SetParent(engineParent);
|
|
engineParent.SetParent(centerParent);
|
|
centerParent.localPosition -= new Vector3(0f, centerParentMoveYMax * 0.5f, 0f);
|
|
animPosY = centerParent.GetComponent<FishPartAnim>();
|
|
if ((bool)animPosY)
|
|
{
|
|
animPosY.unscaledTime = false;
|
|
}
|
|
}
|
|
engineAudioObject = AudioController.Play(engineSound);
|
|
if (!isKayak && engineAudioObject == null)
|
|
{
|
|
Debug.LogError("engineAudioObject == null");
|
|
}
|
|
engineIdleAudioObject = AudioController.Play(engineIdleSound, base.transform);
|
|
if ((bool)engineIdleAudioObject)
|
|
{
|
|
engineIdleAudioObject.Pause();
|
|
}
|
|
waterAudioObject = AudioController.Play(waterSound, base.transform);
|
|
if (waterAudioObject != null)
|
|
{
|
|
waterAudioObject.Pause();
|
|
}
|
|
UpdateEngineSound(false);
|
|
if ((bool)fishScareCollider)
|
|
{
|
|
fishScareCollider.parent = null;
|
|
fishScareCollider.gameObject.SetActive(true);
|
|
Utilities.SetLayerRecursively(fishScareCollider.gameObject, "Boat");
|
|
}
|
|
RefreshRodStands();
|
|
ChangeState(BoatState.IDLE);
|
|
}
|
|
|
|
private void Start()
|
|
{
|
|
}
|
|
|
|
public void Initialize()
|
|
{
|
|
if ((bool)FisheryEditor.Instance)
|
|
{
|
|
return;
|
|
}
|
|
if (startPosition.parent != null)
|
|
{
|
|
startPosition.parent = null;
|
|
startPosition.localScale = Vector3.one;
|
|
startPosition.position = base.transform.position;
|
|
startPosition.eulerAngles = base.transform.eulerAngles;
|
|
}
|
|
fishingPlayer = GameController.Instance.fishingPlayer;
|
|
if (!GameController.Instance.iceLevel)
|
|
{
|
|
InitializeWaterSubstract();
|
|
LeanTween.delayedCall(3f, (Action)delegate
|
|
{
|
|
InitializeWaterSubstract();
|
|
});
|
|
}
|
|
for (int num = 0; num < waterSplashEffectsPos.Count; num++)
|
|
{
|
|
ParticleSystem particleSystem = UnityEngine.Object.Instantiate(GameController.Instance.waterEffectsManager.GetSplashParticlePrefab(WaterEffectsManager.SplashSize.LARGE));
|
|
particleSystem.transform.parent = waterSplashEffectsPos[num].transform;
|
|
particleSystem.transform.localPosition = Vector3.zero;
|
|
particleSystem.transform.localEulerAngles = Vector3.zero;
|
|
waterSplashEffects.Add(particleSystem);
|
|
}
|
|
initialized = true;
|
|
}
|
|
|
|
private void OnCollisionEnter(Collision col)
|
|
{
|
|
if (!FisheryEditor.Instance && initialized && currentState == BoatState.PLAYER_DRIVING && collisionSoundTimer <= 0f && (col.gameObject.layer == LayerMask.NameToLayer("Default") || col.gameObject.layer == LayerMask.NameToLayer("Terrain")))
|
|
{
|
|
string empty = string.Empty;
|
|
CollisionSound component = col.gameObject.GetComponent<CollisionSound>();
|
|
empty = (component ? component.GetSound() : ((!col.gameObject.HasTag("TERRAIN")) ? collisionDefaultSound : collisionTerrainSound));
|
|
float num = currentSpeedFx * 5f;
|
|
Debug.Log("collisionSoundName: " + empty + " col: " + col.gameObject.name + " volume: " + num);
|
|
AudioController.Play(empty, base.transform, num);
|
|
collisionSoundTimer = 1f;
|
|
}
|
|
}
|
|
|
|
public void InitializeWaterSubstract()
|
|
{
|
|
waterVolumeSubstract = GetComponentInChildren<WaterVolumeSubtract>(true);
|
|
if ((bool)waterVolumeSubstract)
|
|
{
|
|
waterVolumeSubstract.gameObject.SetActive(false);
|
|
waterVolumeSubstract.AssignTo(null);
|
|
waterVolumeSubstract.gameObject.SetActive(true);
|
|
waterVolumeSubstract.enabled = true;
|
|
waterVolumeSubstract.AssignTo(GameController.Instance.water);
|
|
if (propeller != null)
|
|
{
|
|
Utilities.SetLayerRecursively(waterVolumeSubstract.gameObject, "TransparentFX");
|
|
}
|
|
}
|
|
if (waterVolumeSubstract == null)
|
|
{
|
|
Utilities.LogError("InitializeWaterSubstract() waterVolumeSubstract == null");
|
|
}
|
|
if (GameController.Instance.water == null)
|
|
{
|
|
Utilities.LogError("InitializeWaterSubstract() GameController.Instance.water");
|
|
}
|
|
}
|
|
|
|
public void ResetRotations()
|
|
{
|
|
engineParent.localEulerAngles = Vector3.zero;
|
|
centerParent.localEulerAngles = Vector3.zero;
|
|
engineParentPrevRotation = Vector3.zero;
|
|
playerCurrentMove = Vector3.zero;
|
|
playerCurrentRotation = Vector3.zero;
|
|
keyPressedW = false;
|
|
keyPressedS = false;
|
|
keyPressedA = false;
|
|
keyPressedD = false;
|
|
}
|
|
|
|
public void ChangeState(BoatState newState)
|
|
{
|
|
StopBoat();
|
|
ResetRotations();
|
|
interactiveEnter.GetComponent<Collider>().enabled = newState == BoatState.IDLE;
|
|
interactiveEnter.GetComponent<BoatInteractive>().canInteract = newState == BoatState.IDLE;
|
|
if ((bool)interactiveExit)
|
|
{
|
|
interactiveExit.gameObject.SetActive(newState != BoatState.IDLE);
|
|
interactiveExit.GetComponent<Collider>().enabled = newState == BoatState.PLAYER_FISHING;
|
|
}
|
|
interactiveDriveStart.GetComponent<Collider>().enabled = newState == BoatState.PLAYER_FISHING;
|
|
keepMovingForward = false;
|
|
if ((bool)VRManager.Instance && ((VRManager.Instance.IsControllersInput() && UtilitiesInput.GetButton("VR_BOAT_THROTTLE_UP")) || (!VRManager.Instance.IsControllersInput() && UtilitiesInput.moveAxis.y > 0.3f)) && newState == BoatState.PLAYER_FISHING && !isKayak)
|
|
{
|
|
keepMovingForward = true;
|
|
}
|
|
foreach (GameObject item in turnOffWhileDriving)
|
|
{
|
|
item.SetActive(newState != BoatState.PLAYER_DRIVING);
|
|
}
|
|
if (keepMovingForward)
|
|
{
|
|
foreach (GameObject item2 in turnOffWhileKeepMoving)
|
|
{
|
|
item2.SetActive(false);
|
|
}
|
|
}
|
|
foreach (GameObject waterEffect in waterEffects)
|
|
{
|
|
Color color = waterEffect.GetComponent<MeshRenderer>().material.GetColor("_TintColor");
|
|
if (keepMovingForward)
|
|
{
|
|
color.a = 0.65f;
|
|
}
|
|
else if (newState != BoatState.PLAYER_DRIVING)
|
|
{
|
|
color.a = 0f;
|
|
}
|
|
waterEffect.GetComponent<MeshRenderer>().material.SetColor("_TintColor", color);
|
|
}
|
|
if (newState == BoatState.PLAYER_DRIVING)
|
|
{
|
|
myRigidbody.isKinematic = false;
|
|
if ((bool)fishingPlayer)
|
|
{
|
|
fishingPlayer.amplifyMotionEffect.CameraMotionMult = 0f;
|
|
}
|
|
if (!rodStand || rodStand.rodPlacesOccupied == 0)
|
|
{
|
|
GameController.Instance.fishViewCurrentDistance = 0f;
|
|
}
|
|
if (VRManager.IsVROn())
|
|
{
|
|
ChangeTeleportPlatformsLayers(false);
|
|
fishingPlayer.ChangeVRCameraHeight(fishingPlayer.vrWheelMoveLastPosition);
|
|
}
|
|
}
|
|
else if (newState != BoatState.PLAYER_DRIVING)
|
|
{
|
|
myRigidbody.isKinematic = true;
|
|
if ((bool)fishingPlayer)
|
|
{
|
|
fishingPlayer.amplifyMotionEffect.CameraMotionMult = 1f;
|
|
if (VRManager.IsVROn())
|
|
{
|
|
fishingPlayer.ChangeVRCameraHeight(VRManager.Instance.cameraHeight);
|
|
}
|
|
}
|
|
GameController.Instance.fishViewCurrentDistance = GameController.Instance.fishViewDistance;
|
|
UtilitiesInput.StopVibration();
|
|
}
|
|
pauseFloating = false;
|
|
currentState = newState;
|
|
}
|
|
|
|
public void PlayEngineStartSound(bool start)
|
|
{
|
|
if (!(engineIdleAudioObject == null))
|
|
{
|
|
if (start)
|
|
{
|
|
AudioController.Play(engineStartSound, base.transform);
|
|
engineIdleAudioObject.Play();
|
|
engineIdleAudioObject.FadeIn(1f);
|
|
}
|
|
else if (engineIdleAudioObject.IsPlaying())
|
|
{
|
|
AudioController.Play(engineStopSound, base.transform);
|
|
engineIdleAudioObject.Pause(2f);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void EnterBoat(bool enter)
|
|
{
|
|
if (enter)
|
|
{
|
|
ChangeState(BoatState.PLAYER_FISHING);
|
|
}
|
|
else
|
|
{
|
|
ChangeState(BoatState.IDLE);
|
|
}
|
|
if (!enter)
|
|
{
|
|
base.transform.position = startPosition.position;
|
|
base.transform.rotation = startPosition.rotation;
|
|
}
|
|
GameController.Instance.hudManager.kgfMapSystem.SetTarget((!enter) ? fishingPlayer.gameObject : base.gameObject);
|
|
if (enter)
|
|
{
|
|
if ((bool)rodStand)
|
|
{
|
|
foreach (RodStand.RodPlace rodPlace in rodStand.rodPlaces)
|
|
{
|
|
rodPlace.rodTrigger.GetComponent<RodStandTrigger>().InteractDistance = ((!isKayak) ? 2.8f : 3.2f);
|
|
}
|
|
}
|
|
InitializeWaterSubstract();
|
|
}
|
|
StopBoat();
|
|
}
|
|
|
|
public void ReturnBoat()
|
|
{
|
|
base.transform.position = returnPosition.position;
|
|
base.transform.rotation = returnPosition.rotation;
|
|
StopBoat();
|
|
}
|
|
|
|
public void StopBoat()
|
|
{
|
|
myRigidbody.velocity = Vector3.zero;
|
|
myRigidbody.angularVelocity = Vector3.zero;
|
|
engineForce = 0f;
|
|
UpdateEngineSound(false);
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
if (Time.timeScale == 0f || ((bool)BugReporter.Instance && BugReporter.Instance.isVisible) || (VRManager.IsVROn() && GameController.Instance.IsQuickMenu()) || (bool)FisheryEditor.Instance || !initialized)
|
|
{
|
|
return;
|
|
}
|
|
if (exitPosition == null && GameController.Instance.spawnPoints != null && GameController.Instance.spawnPoints.Length > 0)
|
|
{
|
|
exitPosition = GameController.Instance.spawnPoints[0].transform;
|
|
}
|
|
if ((bool)fishScareCollider)
|
|
{
|
|
fishScareCollider.position = base.transform.position;
|
|
fishScareCollider.rotation = base.transform.rotation;
|
|
}
|
|
if ((!GlobalSettings.Instance || GlobalSettings.Instance.turnOnMyCheats) && Input.GetKeyDown(KeyCode.J))
|
|
{
|
|
InitializeWaterSubstract();
|
|
}
|
|
if (currentState == BoatState.PLAYER_DRIVING)
|
|
{
|
|
keyPressedW = false;
|
|
keyPressedS = false;
|
|
keyPressedA = false;
|
|
keyPressedD = false;
|
|
if (!HUDManager.Instance.hudMultiplayer.isInInputMode)
|
|
{
|
|
if ((VRManager.Instance.IsControllersInput() && UtilitiesInput.GetButton("VR_BOAT_THROTTLE_UP")) || (!VRManager.Instance.IsControllersInput() && UtilitiesInput.moveAxis.y > 0.3f))
|
|
{
|
|
keyPressedW = true;
|
|
float num = forwardForce;
|
|
if (HasRodsWithFishOnPod() || (HasRodsOnPod() && !UtilitiesInput.GetButton("RUN")))
|
|
{
|
|
num *= trollingForceMultiplier;
|
|
}
|
|
if ((bool)forcePosition)
|
|
{
|
|
myRigidbody.AddForceAtPosition(base.transform.forward * forwardForce * Time.deltaTime, forcePosition.position);
|
|
}
|
|
else
|
|
{
|
|
myRigidbody.AddForce(base.transform.forward * num * Time.deltaTime);
|
|
}
|
|
}
|
|
else if ((VRManager.Instance.IsControllersInput() && UtilitiesInput.GetButton("VR_BOAT_THROTTLE_DOWN")) || (!VRManager.Instance.IsControllersInput() && UtilitiesInput.moveAxis.y < -0.3f))
|
|
{
|
|
keyPressedS = true;
|
|
if ((bool)forcePosition)
|
|
{
|
|
myRigidbody.AddForceAtPosition(-base.transform.forward * backwardForce * Time.deltaTime, forcePosition.position);
|
|
}
|
|
else
|
|
{
|
|
myRigidbody.AddForce(-base.transform.forward * backwardForce * Time.deltaTime);
|
|
}
|
|
}
|
|
}
|
|
noTurningTimer -= Time.deltaTime;
|
|
if (noTurningTimer < 0f)
|
|
{
|
|
noTurningTimer = 0f;
|
|
}
|
|
float num2 = 0f;
|
|
bool flag = VRManager.Instance.IsVRDriveBoat() && !isKayak && (bool)vrBoatWheel;
|
|
if (!HUDManager.Instance.hudMultiplayer.isInInputMode)
|
|
{
|
|
if (flag)
|
|
{
|
|
num2 = vrBoatWheel.MakeUpdate();
|
|
currentWheelFactor = Mathf.Abs(num2);
|
|
}
|
|
else
|
|
{
|
|
currentWheelFactor = Mathf.Abs(currentWheelRotation / maxWheelRotationF);
|
|
}
|
|
if ((flag && num2 > 0.05f) || (!flag && UtilitiesInput.moveAxis.x < -0.5f))
|
|
{
|
|
if (keyPressedW || keyPressedS || isKayak)
|
|
{
|
|
keyPressedA = true;
|
|
if (flag)
|
|
{
|
|
myRigidbody.AddTorque(-base.transform.up * turnForce * Time.deltaTime * ((!keyPressedS) ? 1f : (-1f)) * (currentWheelFactor * 1.5f));
|
|
}
|
|
else
|
|
{
|
|
myRigidbody.AddTorque(-base.transform.up * turnForce * Time.deltaTime * ((!keyPressedS) ? 1f : (-1f)) * (currentWheelFactor + 0.5f));
|
|
}
|
|
noTurningTimer = 0.6f;
|
|
}
|
|
if (!flag)
|
|
{
|
|
currentWheelRotation += wheelRotationSpeed * Time.deltaTime;
|
|
}
|
|
}
|
|
else if ((flag && num2 < 0.05f) || (!flag && UtilitiesInput.moveAxis.x > 0.5f))
|
|
{
|
|
if (keyPressedW || keyPressedS || isKayak)
|
|
{
|
|
keyPressedD = true;
|
|
if (flag)
|
|
{
|
|
myRigidbody.AddTorque(base.transform.up * turnForce * Time.deltaTime * ((!keyPressedS) ? 1f : (-1f)) * (currentWheelFactor * 1.5f));
|
|
}
|
|
else
|
|
{
|
|
myRigidbody.AddTorque(base.transform.up * turnForce * Time.deltaTime * ((!keyPressedS) ? 1f : (-1f)) * (currentWheelFactor + 0.5f));
|
|
}
|
|
noTurningTimer = 0.6f;
|
|
}
|
|
if (!flag)
|
|
{
|
|
currentWheelRotation -= wheelRotationSpeed * Time.deltaTime;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (currentWheelRotation > 0f)
|
|
{
|
|
currentWheelRotation -= wheelRotationSpeed * Time.deltaTime * 1f;
|
|
if (currentWheelRotation < 0f)
|
|
{
|
|
currentWheelRotation = 0f;
|
|
}
|
|
}
|
|
if (currentWheelRotation < 0f)
|
|
{
|
|
currentWheelRotation += wheelRotationSpeed * Time.deltaTime * 1f;
|
|
if (currentWheelRotation > 0f)
|
|
{
|
|
currentWheelRotation = 0f;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (isKayak)
|
|
{
|
|
if (keyPressedW)
|
|
{
|
|
fishingPlayer.currentHands.kayakHandsAnimator.SetInteger("KayakHandsState", 1);
|
|
}
|
|
else if (keyPressedS)
|
|
{
|
|
fishingPlayer.currentHands.kayakHandsAnimator.SetInteger("KayakHandsState", -1);
|
|
}
|
|
else if (keyPressedD)
|
|
{
|
|
fishingPlayer.currentHands.kayakHandsAnimator.SetInteger("KayakHandsState", 2);
|
|
}
|
|
else if (keyPressedA)
|
|
{
|
|
fishingPlayer.currentHands.kayakHandsAnimator.SetInteger("KayakHandsState", 3);
|
|
}
|
|
else
|
|
{
|
|
fishingPlayer.currentHands.kayakHandsAnimator.SetInteger("KayakHandsState", 0);
|
|
}
|
|
}
|
|
if (!flag)
|
|
{
|
|
currentWheelRotation = Mathf.Clamp(currentWheelRotation, 0f - maxWheelRotationF, maxWheelRotationF);
|
|
steeringWheel.transform.localEulerAngles = new Vector3(0f, 0f, currentWheelRotation);
|
|
}
|
|
UpdateEngineSound(true);
|
|
foreach (GameObject waterEffect in waterEffects)
|
|
{
|
|
Color color = waterEffect.GetComponent<MeshRenderer>().material.GetColor("_TintColor");
|
|
color.a += wakeEffectSpeed * Time.deltaTime * ((!keyPressedW) ? (-1f) : 1f);
|
|
color.a = Mathf.Clamp(color.a, 0f, 0.7f);
|
|
waterEffect.GetComponent<MeshRenderer>().material.SetColor("_TintColor", color);
|
|
waterEffect.transform.eulerAngles = new Vector3(0f, waterEffect.transform.eulerAngles.y, 0f);
|
|
}
|
|
if ((bool)propeller)
|
|
{
|
|
propeller.transform.Rotate(Vector3.up * Time.deltaTime * propellerSpeed);
|
|
}
|
|
myRigidbody.drag = ((!keyPressedW) ? dragIdle.x : dragEngine.x);
|
|
myRigidbody.angularDrag = ((!keyPressedW) ? dragIdle.y : dragEngine.y);
|
|
}
|
|
else if (currentState == BoatState.PLAYER_FISHING && keepMovingForward)
|
|
{
|
|
Vector3 force = base.transform.forward * forwardForce * trollingForceMultiplier * Time.deltaTime;
|
|
if (HasRodsWithFishOnPod())
|
|
{
|
|
force *= 0.3f;
|
|
}
|
|
myRigidbody.AddForce(force);
|
|
myRigidbody.isKinematic = false;
|
|
foreach (GameObject waterEffect2 in waterEffects)
|
|
{
|
|
waterEffect2.transform.localEulerAngles = Vector3.zero;
|
|
}
|
|
if ((bool)propeller)
|
|
{
|
|
propeller.transform.Rotate(Vector3.up * Time.deltaTime * propellerSpeed);
|
|
}
|
|
UpdateEngineSound(true);
|
|
}
|
|
if ((bool)rodStand && (keyPressedW || keepMovingForward))
|
|
{
|
|
foreach (RodStand.RodPlace rodPlace in rodStand.rodPlaces)
|
|
{
|
|
if ((bool)rodPlace.fishingRod && (rodPlace.fishingRod.fishingHands.isSpinningRig || rodPlace.fishingRod.fishingHands.isFlyRig))
|
|
{
|
|
rodPlace.fishingRod.fishingHands.spinningMethodController.SpinningStateEvent(SpinningMethodController.SpinningState.MOVE_MEDIUM);
|
|
}
|
|
}
|
|
if (fishingPlayer.currentHands.baitWasThrown)
|
|
{
|
|
fishingPlayer.currentHands.spinningMethodController.SpinningStateEvent(SpinningMethodController.SpinningState.MOVE_MEDIUM);
|
|
}
|
|
}
|
|
currentSpeedFx = Mathf.Clamp01(myRigidbody.velocity.magnitude / speedFxThreshold);
|
|
UpdateBoatFloating();
|
|
if (collisionSoundTimer > 0f)
|
|
{
|
|
collisionSoundTimer -= Time.deltaTime;
|
|
}
|
|
if ((bool)gaugeSpeed)
|
|
{
|
|
gaugeSpeed.SetValue(myRigidbody.velocity.magnitude * 3.6f / 70f);
|
|
}
|
|
if ((bool)gaugeDirection)
|
|
{
|
|
gaugeDirection.SetValue(0.5f + (0f - Utilities.GetAngle180Range(engineParent.localEulerAngles.x)) / engineParentMaxRotationX * 0.5f);
|
|
}
|
|
}
|
|
|
|
private void LateUpdate()
|
|
{
|
|
if (Time.timeScale == 0f || (bool)FisheryEditor.Instance || !initialized)
|
|
{
|
|
return;
|
|
}
|
|
if (isKayak && (bool)fishingPlayer && fishingPlayer.boatSimulator == this)
|
|
{
|
|
if (((!fishingPlayer.ufpsCamera.enabled) ? fishingPlayer.ufpsCamera.transform.localPosition.y : fishingPlayer.ufpsCamera.PositionOffset.y) > kayakSitHeight)
|
|
{
|
|
fishingPlayer.SitDown(kayakSitHeight, false);
|
|
fishingPlayer.ufpsCamera.transform.localPosition = new Vector3(fishingPlayer.ufpsCamera.transform.localPosition.x, fishingPlayer.boatSimulator.kayakSitHeight, fishingPlayer.ufpsCamera.transform.localPosition.z);
|
|
}
|
|
fishingPlayer.currentHands.kayakHandsAnimation.transform.localPosition = fishingPlayer.currentHands.kayakHandsSwimPos;
|
|
}
|
|
if (keepMovingForward)
|
|
{
|
|
animPosY.updatePosition = false;
|
|
return;
|
|
}
|
|
animPosY.updatePosition = true;
|
|
Vector3 eulerAngles = base.transform.eulerAngles;
|
|
eulerAngles.x = 0f;
|
|
eulerAngles.z = 0f;
|
|
base.transform.eulerAngles = eulerAngles;
|
|
float num = 0f;
|
|
float num2 = 0f;
|
|
if (VRManager.Instance.IsComfortableDriveBoat())
|
|
{
|
|
animPosY.updatePosition = false;
|
|
animPosY.useX = false;
|
|
animPosY.useY = false;
|
|
animPosY.useZ = false;
|
|
}
|
|
else
|
|
{
|
|
if (currentState == BoatState.PLAYER_DRIVING)
|
|
{
|
|
}
|
|
if ((bool)animPosY)
|
|
{
|
|
animPosY.multiplier = 1f + currentSpeedFx * animPosYMaxMultiplier;
|
|
animPosY.duration = Mathf.Lerp(animPosYDuration.x, animPosYDuration.y, 1f - currentSpeedFx);
|
|
}
|
|
if (currentState == BoatState.PLAYER_DRIVING)
|
|
{
|
|
num = Utilities.GetSmoothFactor(maxValue: keyPressedW ? playerForwardMoveMax.x : ((!keyPressedS) ? 0f : playerForwardMoveMax.y), currentValue: playerCurrentMove.z, threshold: 0.75f);
|
|
if (keyPressedW)
|
|
{
|
|
playerCurrentMove.z -= playerForwardMoveSpeed.x * Time.deltaTime * num;
|
|
}
|
|
else if (keyPressedS)
|
|
{
|
|
playerCurrentMove.z += playerForwardMoveSpeed.y * Time.deltaTime * num;
|
|
}
|
|
else if (playerCurrentMove.z < 0f)
|
|
{
|
|
playerCurrentMove.z += playerForwardMoveSpeed.x * Time.deltaTime * 0.5f * num;
|
|
}
|
|
else if (playerCurrentMove.z > 0f)
|
|
{
|
|
playerCurrentMove.z -= playerForwardMoveSpeed.y * Time.deltaTime * 0.5f * num;
|
|
}
|
|
playerCurrentMove.z = Mathf.Clamp(playerCurrentMove.z, playerForwardMoveMax.x, playerForwardMoveMax.y);
|
|
num = Utilities.GetSmoothFactor(maxValue: keyPressedA ? (0f - playerSideRotateMax) : ((!keyPressedD) ? 0f : playerSideRotateMax), currentValue: playerCurrentRotation.z, threshold: 0.75f);
|
|
if (keyPressedA)
|
|
{
|
|
playerCurrentRotation.z -= playerSideRotateSpeed * Time.deltaTime * num;
|
|
}
|
|
else if (keyPressedD)
|
|
{
|
|
playerCurrentRotation.z += playerSideRotateSpeed * Time.deltaTime * num;
|
|
}
|
|
else if (playerCurrentRotation.z < 0f)
|
|
{
|
|
playerCurrentRotation.z += playerSideRotateSpeed * Time.deltaTime * 0.5f * num;
|
|
}
|
|
else if (playerCurrentRotation.z > 0f)
|
|
{
|
|
playerCurrentRotation.z -= playerSideRotateSpeed * Time.deltaTime * 0.5f * num;
|
|
}
|
|
playerCurrentRotation.z = Mathf.Clamp(playerCurrentRotation.z, 0f - playerSideRotateMax, playerSideRotateMax);
|
|
fishingPlayer.transform.localPosition = playerCurrentMove;
|
|
fishingPlayer.transform.localEulerAngles = playerCurrentRotation;
|
|
}
|
|
Vector3 localEulerAngles = engineParentPrevRotation;
|
|
if (localEulerAngles.x > 180f)
|
|
{
|
|
localEulerAngles.x -= 360f;
|
|
}
|
|
if (localEulerAngles.z > 180f)
|
|
{
|
|
localEulerAngles.z -= 360f;
|
|
}
|
|
num = Utilities.GetSmoothFactor(localEulerAngles.x, 0f - engineParentMaxRotationX, 0.85f);
|
|
if (keyPressedW)
|
|
{
|
|
localEulerAngles.x -= engineParentRotationSpeed.x * Time.deltaTime * num;
|
|
}
|
|
else
|
|
{
|
|
localEulerAngles.x += engineParentRotationSpeed.x * 1f * Time.deltaTime;
|
|
}
|
|
num = Utilities.GetSmoothFactor(localEulerAngles.z, (!keyPressedA) ? engineParentMaxRotationZ.x : engineParentMaxRotationZ.y, 0.7f);
|
|
if (keyPressedA)
|
|
{
|
|
localEulerAngles.z += engineParentRotationSpeed.z * Time.deltaTime * (currentWheelFactor + 0.5f) * num;
|
|
}
|
|
else if (keyPressedD)
|
|
{
|
|
localEulerAngles.z -= engineParentRotationSpeed.z * Time.deltaTime * (currentWheelFactor + 0.5f) * num;
|
|
}
|
|
else if (Mathf.Abs(localEulerAngles.z) < 0.1f)
|
|
{
|
|
localEulerAngles.z = 0f;
|
|
}
|
|
else
|
|
{
|
|
localEulerAngles.z += engineParentRotationSpeed.z * Time.deltaTime * Mathf.Lerp(0.05f, 1.2f, Mathf.Abs(localEulerAngles.z / engineParentMaxRotationZ.x)) * ((!(localEulerAngles.z > 0f)) ? 1f : (-1f)) * (1f - noTurningTimer / 0.6f);
|
|
}
|
|
localEulerAngles.x = Mathf.Clamp(localEulerAngles.x, 0f - engineParentMaxRotationX, 0f);
|
|
localEulerAngles.z = Mathf.Clamp(localEulerAngles.z, engineParentMaxRotationZ.x, engineParentMaxRotationZ.y);
|
|
engineParentPrevRotation = localEulerAngles;
|
|
engineParent.localEulerAngles = localEulerAngles;
|
|
}
|
|
if ((bool)fishingPlayer && fishingPlayer.currentState == FishingPlayer.PlayerState.WATCH_FISH && fishingPlayer.fish.watchStyle == Fish.WatchStyle.BOAT)
|
|
{
|
|
base.transform.position = new Vector3(base.transform.position.x, startPosition.position.y - 0.5f, base.transform.position.z);
|
|
}
|
|
else
|
|
{
|
|
base.transform.position = new Vector3(base.transform.position.x, startPosition.position.y, base.transform.position.z);
|
|
}
|
|
}
|
|
|
|
public void UpdateBoatFloating()
|
|
{
|
|
if (pauseFloating || ((bool)fishingPlayer.boatSimulator && VRManager.Instance.IsComfortableDriveBoat()))
|
|
{
|
|
return;
|
|
}
|
|
Vector3 localEulerAngles = centerParent.localEulerAngles;
|
|
bool flag = false;
|
|
if (floatingTarget.z > 0f)
|
|
{
|
|
floatingCurrent.z += floatingSpeed.z * Time.deltaTime;
|
|
if (floatingCurrent.z >= floatingTarget.z)
|
|
{
|
|
flag = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
floatingCurrent.z -= floatingSpeed.z * Time.deltaTime;
|
|
if (floatingCurrent.z <= floatingTarget.z)
|
|
{
|
|
flag = true;
|
|
}
|
|
}
|
|
if (flag)
|
|
{
|
|
floatingPrevTarget.z = floatingTarget.z;
|
|
floatingTarget.z = UnityEngine.Random.Range(1f, centerParentRotZMax) * ((!(floatingTarget.z > 0f)) ? 1f : (-1f));
|
|
floatingSpeed.z = UnityEngine.Random.Range(0.8f * centerParentRotZSpeed, 1.2f * centerParentRotZSpeed);
|
|
floatingTarget.z *= 1f + currentSpeedFx * floatingTargetMultiplier;
|
|
floatingSpeed.z *= 1f + currentSpeedFx * floatingSpeedMultiplier;
|
|
}
|
|
float t = floatingLerpCurve.Evaluate(Mathf.Abs(floatingCurrent.z - floatingPrevTarget.z) / Mathf.Abs(floatingPrevTarget.z - floatingTarget.z));
|
|
localEulerAngles.z = Mathf.Lerp(floatingPrevTarget.z, floatingTarget.z, t);
|
|
flag = false;
|
|
if (floatingTarget.x > 0f)
|
|
{
|
|
floatingCurrent.x += floatingSpeed.x * Time.deltaTime;
|
|
if (floatingCurrent.x >= floatingTarget.x)
|
|
{
|
|
flag = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
floatingCurrent.x -= floatingSpeed.x * Time.deltaTime;
|
|
if (floatingCurrent.x <= floatingTarget.x)
|
|
{
|
|
flag = true;
|
|
}
|
|
}
|
|
if (flag)
|
|
{
|
|
floatingPrevTarget.x = floatingTarget.x;
|
|
floatingTarget.x = UnityEngine.Random.Range(1f, centerParentRotXMax) * ((!(floatingTarget.x > 0f)) ? 1f : (-1f));
|
|
floatingSpeed.x = UnityEngine.Random.Range(0.8f * centerParentRotXSpeed, 1.2f * centerParentRotXSpeed);
|
|
floatingTarget.x *= 1f + currentSpeedFx * floatingTargetMultiplier;
|
|
floatingSpeed.x *= 1f + currentSpeedFx * floatingSpeedMultiplier;
|
|
}
|
|
t = floatingLerpCurve.Evaluate(Mathf.Abs(floatingCurrent.x - floatingPrevTarget.x) / Mathf.Abs(floatingPrevTarget.x - floatingTarget.x));
|
|
localEulerAngles.x = Mathf.Lerp(floatingPrevTarget.x, floatingTarget.x, t);
|
|
centerParent.localEulerAngles = localEulerAngles;
|
|
}
|
|
|
|
public void UpdateEngineSound(bool started)
|
|
{
|
|
bool flag = started;
|
|
if (flag)
|
|
{
|
|
flag = keyPressedW || keyPressedS || keepMovingForward;
|
|
}
|
|
if ((bool)engineAudioObject)
|
|
{
|
|
if (flag)
|
|
{
|
|
if (engineAudioObject.IsPaused())
|
|
{
|
|
engineAudioObject.Unpause();
|
|
}
|
|
if ((bool)waterAudioObject && waterAudioObject.IsPaused())
|
|
{
|
|
waterAudioObject.Unpause();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!engineAudioObject.IsPaused())
|
|
{
|
|
}
|
|
if ((bool)waterAudioObject && waterAudioObject.IsPaused())
|
|
{
|
|
}
|
|
}
|
|
}
|
|
foreach (ParticleEmitter waterEmitter in waterEmitters)
|
|
{
|
|
waterEmitter.emit = flag;
|
|
}
|
|
float num = ((keyPressedW || !keyPressedS) ? 1f : 0.7f);
|
|
if (flag && engineForce < num)
|
|
{
|
|
engineForce += engineForceSpeed * Time.deltaTime;
|
|
}
|
|
else
|
|
{
|
|
engineForce -= engineForceSpeed * 1.3f * Time.deltaTime;
|
|
}
|
|
if (flag)
|
|
{
|
|
engineForce = Mathf.Clamp(engineForce, 0.3f, 1f);
|
|
}
|
|
else
|
|
{
|
|
engineForce = Mathf.Clamp(engineForce, 0f, 1f);
|
|
}
|
|
float t = engineForce;
|
|
if ((bool)engineAudioObject)
|
|
{
|
|
if (keepMovingForward)
|
|
{
|
|
engineAudioObject.volume = Mathf.Lerp(engineVolume.x, engineVolume.y, trollingEngineSoundVolume) * AudioController.GetCategoryVolume("SFX");
|
|
engineAudioObject.pitch = Mathf.Lerp(enginePitch.x, enginePitch.y, trollingEngineSoundVolume);
|
|
if ((bool)waterAudioObject)
|
|
{
|
|
waterAudioObject.volume = Mathf.Lerp(waterVolume.x, waterVolume.y, trollingEngineSoundVolume) * AudioController.GetCategoryVolume("SFX");
|
|
}
|
|
}
|
|
else if (started)
|
|
{
|
|
engineAudioObject.volume = Mathf.Lerp(engineVolume.x, engineVolume.y, t) * AudioController.GetCategoryVolume("SFX");
|
|
engineAudioObject.pitch = Mathf.Lerp(enginePitch.x, enginePitch.y, t);
|
|
if ((bool)waterAudioObject)
|
|
{
|
|
waterAudioObject.volume = Mathf.Lerp(waterVolume.x, waterVolume.y, t) * AudioController.GetCategoryVolume("SFX");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
engineAudioObject.volume = 0f;
|
|
engineAudioObject.pitch = 1f;
|
|
if ((bool)waterAudioObject)
|
|
{
|
|
waterAudioObject.volume = 0f;
|
|
}
|
|
}
|
|
}
|
|
if (!keyPressedW)
|
|
{
|
|
return;
|
|
}
|
|
if (engineForce > 0.6f)
|
|
{
|
|
waterSplashTimer -= Time.deltaTime;
|
|
if (waterSplashTimer <= 0f)
|
|
{
|
|
waterSplashTimer = UnityEngine.Random.Range(4f, 10f);
|
|
SplashWater(engineForce);
|
|
}
|
|
}
|
|
waterSplashSmallTimer -= Time.deltaTime;
|
|
if (waterSplashSmallTimer <= 0f)
|
|
{
|
|
waterSplashSmallTimer = UnityEngine.Random.Range(0.03f, 1f);
|
|
}
|
|
}
|
|
|
|
public void SplashWater(float strength)
|
|
{
|
|
if (showCameraDrops)
|
|
{
|
|
fishingPlayer.WaterSplash(strength, 0.2f);
|
|
}
|
|
AudioController.Play("SplashBoatBig_01", fishingPlayer.transform, strength);
|
|
for (int i = 0; i < waterSplashEffects.Count; i++)
|
|
{
|
|
waterSplashEffects[i].Play(true);
|
|
}
|
|
}
|
|
|
|
public void PauseFloating(bool pause)
|
|
{
|
|
if (VRManager.Instance.IsComfortableDriveBoat())
|
|
{
|
|
pause = true;
|
|
}
|
|
pauseFloating = pause;
|
|
animPosY.enabled = !pause;
|
|
}
|
|
|
|
public bool HasRodsOnPod()
|
|
{
|
|
if ((bool)rodStand)
|
|
{
|
|
foreach (RodStand.RodPlace rodPlace in rodStand.rodPlaces)
|
|
{
|
|
if ((bool)rodPlace.fishingRod)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public bool HasRodsWithFishOnPod()
|
|
{
|
|
if ((bool)rodStand)
|
|
{
|
|
for (int i = 0; i < rodStand.rodPlaces.Count; i++)
|
|
{
|
|
if ((bool)rodStand.rodPlaces[i].fishingRod && (bool)rodStand.rodPlaces[i].fishingRod.fishingHands.bait.fish)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void StopKeepMoving()
|
|
{
|
|
keepMovingForward = false;
|
|
float num = 4f;
|
|
foreach (GameObject item in turnOffWhileKeepMoving)
|
|
{
|
|
item.SetActive(!keepMovingForward);
|
|
}
|
|
LeanTween.value(0.65f, 0f, num * 0.6f).setOnUpdate(delegate(float value)
|
|
{
|
|
foreach (GameObject waterEffect in waterEffects)
|
|
{
|
|
Color color = waterEffect.GetComponent<MeshRenderer>().material.GetColor("_TintColor");
|
|
color.a = value;
|
|
waterEffect.GetComponent<MeshRenderer>().material.SetColor("_TintColor", color);
|
|
}
|
|
});
|
|
myRigidbody.velocity = Vector3.zero;
|
|
myRigidbody.angularVelocity = Vector3.zero;
|
|
engineForce = 0f;
|
|
if (!keepMovingForward)
|
|
{
|
|
LeanTween.value(engineAudioObject.volume, 0f, num).setOnUpdate(delegate(float value)
|
|
{
|
|
engineAudioObject.volume = value;
|
|
});
|
|
LeanTween.value(waterAudioObject.volume, 0f, num).setOnUpdate(delegate(float value)
|
|
{
|
|
waterAudioObject.volume = value;
|
|
});
|
|
}
|
|
fishingPlayer.transform.parent = ((!keepMovingForward) ? enterPosition : null);
|
|
}
|
|
|
|
public void RefreshRodStands()
|
|
{
|
|
if (!GlobalSettings.Instance)
|
|
{
|
|
return;
|
|
}
|
|
bool flag = permanentRodStand;
|
|
if (GlobalSettings.Instance.equipmentManager.FindEquipment(EquipmentObject.EquipmentType.ROD_STAND, "BOAT_FISH_HOLDERS_01").isBought)
|
|
{
|
|
flag = true;
|
|
}
|
|
if ((bool)this.rodStand && !flag)
|
|
{
|
|
this.rodStand.gameObject.SetActive(false);
|
|
this.rodStand = null;
|
|
}
|
|
else
|
|
{
|
|
if ((bool)this.rodStand || !flag)
|
|
{
|
|
return;
|
|
}
|
|
RodStand[] componentsInChildren = GetComponentsInChildren<RodStand>(true);
|
|
RodStand[] array = componentsInChildren;
|
|
foreach (RodStand rodStand in array)
|
|
{
|
|
if (rodStand.transform.parent == objectsParent)
|
|
{
|
|
this.rodStand = rodStand;
|
|
}
|
|
}
|
|
if ((bool)this.rodStand)
|
|
{
|
|
this.rodStand.gameObject.SetActive(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void ChangeTeleportPlatformsLayers(bool setMovingPlatforms)
|
|
{
|
|
}
|
|
}
|