Ultimate-Fishing-Simulator-3-Demo/Assets/Scripts/Assembly-CSharp/CameraManager.cs

using Cinemachine;
using Obvious.Soap;
using QFSW.QC;
using SoapCustomVariable;
using UnityEngine;
using UnityEngine.Rendering.HighDefinition;

public class CameraManager : MonoBehaviour
{
	public Transform vehicleCamLook;

	public Transform fppCamLook;

	public Transform vehicleCamTarget;

	public BoolVariable IsDebugMode;

	public BoolVariable IsUnderwaterCameraEnabled;

	public BoolVariable isZoomButtonPressed;

	public CameraViewTypeVariable CameraViewType;

	public GameObject FreeCameraObject;

	public FloatVariable UnderwaterCameraDistance;

	public FloatVariable lineLength;

	public ScriptableListGameObject cullingObjectList;

	public Vector2Variable movementDirection;

	[SerializeField]
	private HDAdditionalCameraData mainCamera;

	[SerializeField]
	private CinemachineVirtualCamera fppVCam;

	[SerializeField]
	private CinemachineVirtualCamera tppVCam;

	[SerializeField]
	private CinemachineVirtualCamera inventoryVCam;

	[SerializeField]
	private CinemachineVirtualCamera underwaterCam;

	[SerializeField]
	private CinemachineVirtualCamera bobberVCam;

	[SerializeField]
	private GameObjectVariable playerGameObject;

	[SerializeField]
	private BoolVariable isInventoryEnabled;

	[SerializeField]
	private BoolVariable isPhoneEnabled;

	[SerializeField]
	private BoolVariable isFSREnabled;

	[SerializeField]
	private IntVariable settings_antialiasing;

	[SerializeField]
	private FSMVariable playerState;

	[SerializeField]
	private GameObjectVariable lureObject;

	[SerializeField]
	private GameObjectVariable bobberObject;

	[SerializeField]
	private ScriptableEventGameObject onLureInitialized;

	[SerializeField]
	private GameObject phoneCameraObj;

	[SerializeField]
	private ScriptableEventNoParam OnCameraChangeButtonPressed;

	private CinemachineTransposer underwaterTransposer;

	private CinemachineOrbitalTransposer invetoryVCamOrbitalTransposer;

	private Transform tppLookTarget;

	private bool isFPPCam = true;

	private bool isFreeCam;

	private Camera _mainCamera;

	private Transform defaultCamTarget;

	private void Awake()
	{
		underwaterTransposer = underwaterCam.GetCinemachineComponent<CinemachineTransposer>();
		invetoryVCamOrbitalTransposer = inventoryVCam?.GetCinemachineComponent<CinemachineOrbitalTransposer>();
	}

	private void Start()
	{
		switch (CameraViewType.Value)
		{
		case global::CameraViewType.FPP:
			SetFPPCam();
			break;
		case global::CameraViewType.TPP:
			SetTPPCam();
			break;
		case global::CameraViewType.Lure:
			IsUnderwaterCameraEnabled.Value = true;
			ToggleUnderwaterCamera(IsUnderwaterCameraEnabled.Value);
			break;
		}
		IsPhoneEnabled_OnValueChanged(isPhoneEnabled.Value);
		IsFSREnabled_OnValueChanged(isFSREnabled.Value);
		Settings_antialiasing_OnValueChanged(settings_antialiasing.Value);
	}

	private void OnEnable()
	{
		_mainCamera = GetComponentInChildren<Camera>();
		tppLookTarget = tppVCam.LookAt;
		cullingObjectList.Add(_mainCamera.gameObject);
		isFSREnabled.OnValueChanged += IsFSREnabled_OnValueChanged;
		playerState.OnValueChanged += PlayerFSM_OnValueChanged;
		onLureInitialized.OnRaised += OnLureInitialized_OnRaised;
		isInventoryEnabled.OnValueChanged += IsInventoryEnabled_OnValueChanged;
		isPhoneEnabled.OnValueChanged += IsPhoneEnabled_OnValueChanged;
		settings_antialiasing.OnValueChanged += Settings_antialiasing_OnValueChanged;
		bobberObject.OnValueChanged += BobberObjectOnOnValueChanged;
		OnCameraChangeButtonPressed.OnRaised += OnCameraChangeButtonPressed_OnRaised;
		lineLength.OnValueChanged += LineLengthOnOnValueChanged;
	}

	private void LineLengthOnOnValueChanged(float lineLength)
	{
		if (lineLength < 2f)
		{
			ToggleUnderwaterCamera(value: false);
		}
	}

	private void OnDisable()
	{
		cullingObjectList.Remove(_mainCamera.gameObject);
		isFSREnabled.OnValueChanged -= IsFSREnabled_OnValueChanged;
		playerState.OnValueChanged -= PlayerFSM_OnValueChanged;
		onLureInitialized.OnRaised -= OnLureInitialized_OnRaised;
		isInventoryEnabled.OnValueChanged -= IsInventoryEnabled_OnValueChanged;
		isPhoneEnabled.OnValueChanged -= IsPhoneEnabled_OnValueChanged;
		settings_antialiasing.OnValueChanged -= Settings_antialiasing_OnValueChanged;
		bobberObject.OnValueChanged -= BobberObjectOnOnValueChanged;
		OnCameraChangeButtonPressed.OnRaised -= OnCameraChangeButtonPressed_OnRaised;
		lineLength.OnValueChanged -= LineLengthOnOnValueChanged;
	}

	private void BobberObjectOnOnValueChanged(GameObject obj)
	{
		bobberVCam.LookAt = ((obj == null) ? null : obj.transform);
	}

	private void IsFSREnabled_OnValueChanged(bool obj)
	{
		mainCamera.allowDynamicResolution = obj;
	}

	private void IsPhoneEnabled_OnValueChanged(bool obj)
	{
		phoneCameraObj.SetActive(obj);
	}

	private void Settings_antialiasing_OnValueChanged(int obj)
	{
		switch (obj)
		{
		case 0:
			mainCamera.antialiasing = HDAdditionalCameraData.AntialiasingMode.None;
			break;
		case 1:
			mainCamera.antialiasing = HDAdditionalCameraData.AntialiasingMode.FastApproximateAntialiasing;
			break;
		case 2:
			mainCamera.antialiasing = HDAdditionalCameraData.AntialiasingMode.TemporalAntialiasing;
			break;
		case 3:
			mainCamera.antialiasing = HDAdditionalCameraData.AntialiasingMode.SubpixelMorphologicalAntiAliasing;
			break;
		}
	}

	private void IsInventoryEnabled_OnValueChanged(bool obj)
	{
	}

	private void OnLureInitialized_OnRaised(GameObject obj)
	{
		underwaterCam.LookAt = obj.transform;
		underwaterCam.Follow = obj.transform;
	}

	private void PlayerFSM_OnValueChanged(State obj)
	{
		switch (playerState.PreviousValue)
		{
		case State.vehicle:
			fppVCam.Follow = defaultCamTarget;
			break;
		case State.swiming:
			if (isFPPCam)
			{
				SetFPPCam();
			}
			break;
		}
		switch (obj)
		{
		case State.prepare:
		case State.preciseCastIdle:
			SetFPPCam();
			isFPPCam = true;
			break;
		case State.idle:
		case State.collectFish:
			if (IsUnderwaterCameraEnabled.Value)
			{
				ToggleUnderwaterCamera(value: false);
			}
			fppVCam.LookAt = fppCamLook;
			break;
		case State.vehicle:
			defaultCamTarget = fppVCam.Follow;
			fppVCam.LookAt = vehicleCamLook;
			fppVCam.Follow = vehicleCamTarget;
			break;
		case State.swiming:
			SetTPPCam();
			break;
		default:
			fppVCam.LookAt = fppCamLook;
			tppVCam.LookAt = tppLookTarget;
			break;
		}
	}

	private void OnCameraChangeButtonPressed_OnRaised()
	{
		State value = playerState.Value;
		if (value == State.idle || value == State.move || value == State.vehicleFishing || value == State.vehicle)
		{
			isFPPCam = !isFPPCam;
			if (isFPPCam)
			{
				SetFPPCam();
			}
			else
			{
				SetTPPCam();
			}
		}
	}

	[Command("FreeCameraToggle", Platform.AllPlatforms, MonoTargetType.Single)]
	private void FreeCameraToggle()
	{
		isFreeCam = !isFreeCam;
		FreeCameraObject.SetActive(isFreeCam);
	}

	private void Update()
	{
		if (isFreeCam)
		{
			IsDebugMode.Value = true;
		}
		Vector3 vector = -playerGameObject.Value.transform.forward * UnderwaterCameraDistance.Value;
		Vector3 followOffset = new Vector3(vector.x, underwaterTransposer.m_FollowOffset.y, vector.z);
		if (followOffset.y > 2.5f)
		{
			ToggleUnderwaterCamera(value: false);
		}
		float num = -1f;
		float b = 1f;
		if ((bool)underwaterTransposer.FollowTarget && underwaterTransposer.FollowTarget.position.y > num)
		{
			b = num;
		}
		followOffset.y = Mathf.Lerp(followOffset.y, b, Time.deltaTime * 1.5f);
		underwaterTransposer.m_FollowOffset = followOffset;
		float num2 = 9f * Time.deltaTime;
		if (movementDirection.Value.y > 0f)
		{
			UnderwaterCameraDistance.Value -= num2;
		}
		if (movementDirection.Value.y < 0f)
		{
			UnderwaterCameraDistance.Value += num2;
		}
		if (CameraViewType.Value == global::CameraViewType.FPP)
		{
			if (isZoomButtonPressed.Value && (bool)bobberVCam.LookAt)
			{
				bobberVCam.Priority = 100;
			}
			if (!isZoomButtonPressed.Value || !bobberVCam.LookAt)
			{
				bobberVCam.Priority = -1;
			}
		}
		if (!isInventoryEnabled.Value)
		{
			_ = CameraViewType.Value;
			_ = 3;
			if ((playerState.Value == State.fishing || playerState.Value == State.fight) && Input.GetKeyDown(KeyCode.U) && lineLength.Value > 2f)
			{
				ToggleUnderwaterCamera(!IsUnderwaterCameraEnabled.Value);
			}
		}
	}

	private void SetInventoryCamera(bool value)
	{
		inventoryVCam.Priority = (value ? 20 : 0);
	}

	private void ToggleUnderwaterCamera(bool value)
	{
		if (!(underwaterCam.LookAt == null) && !(underwaterCam.Follow == null))
		{
			CameraViewType.Value = global::CameraViewType.Lure;
			if (value)
			{
				underwaterCam.Priority = 10;
				fppVCam.Priority = 0;
				tppVCam.Priority = 0;
				IsUnderwaterCameraEnabled.Value = true;
				bobberVCam.Priority = -1;
			}
			else if (isFPPCam)
			{
				SetFPPCam();
			}
			else
			{
				SetTPPCam();
			}
		}
	}

	public void SetTPPCam()
	{
		IsUnderwaterCameraEnabled.Value = false;
		underwaterCam.Priority = 0;
		fppVCam.Priority = 0;
		tppVCam.Priority = 10;
		CameraViewType.Value = global::CameraViewType.TPP;
		bobberVCam.Priority = -1;
	}

	public void SetFPPCam()
	{
		IsUnderwaterCameraEnabled.Value = false;
		underwaterCam.Priority = 0;
		fppVCam.Priority = 10;
		tppVCam.Priority = 0;
		CameraViewType.Value = global::CameraViewType.FPP;
	}

	public void CameraLookAt(Transform target)
	{
		fppVCam.LookAt = target;
		tppVCam.LookAt = target;
	}

	public void CameraResetLookAt()
	{
		fppVCam.LookAt = fppCamLook;
		tppVCam.LookAt = tppLookTarget;
	}
}