UltimateFishing/Assets/Scripts/Assembly-CSharp/AquariumRender.cs

using System;
using System.Collections.Generic;
using UltimateWater;
using UnityEngine;

[Serializable]
public class AquariumRender
{
	[Serializable]
	public class Water
	{
		public GameObject noWater;

		public GameObject saltwater;

		public GameObject freshwater;
	}

	[Serializable]
	public class PlatformObjects
	{
		public GameObject kwsObject;

		public GameObject crestObject;
	}

	[Serializable]
	public class Environment
	{
		public GameObject environment;

		public KWSWaterSettings kwsWaterSettings;

		public string nameKey;

		public WaterProfile waterProfile;
	}

	[SerializeField]
	private PlatformObjects[] _platformObjects;

	[SerializeField]
	private Water _water;

	[SerializeField]
	private Environment[] _saltwaterEnvironments;

	[SerializeField]
	private Environment[] _freshwaterEnvironments;

	[SerializeField]
	private Material _aquariumCausticsMat;

	[SerializeField]
	private Material _aquariumFishCausticsMat;

	[SerializeField]
	private string _causticsTag = "AquariumCaustics";

	public void SetCaustics()
	{
		Environment[] saltwaterEnvironments = _saltwaterEnvironments;
		foreach (Environment environment in saltwaterEnvironments)
		{
			SetCaustics(environment.environment.transform);
		}
		Environment[] freshwaterEnvironments = _freshwaterEnvironments;
		foreach (Environment environment2 in freshwaterEnvironments)
		{
			SetCaustics(environment2.environment.transform);
		}
	}

	public void SetCaustics(Transform parent)
	{
	}

	public void SetWaterSystem(FishingWaterSystem.WaterSystemType waterType)
	{
		PlatformObjects[] platformObjects = _platformObjects;
		foreach (PlatformObjects platformObjects2 in platformObjects)
		{
			platformObjects2.crestObject.SetActive(waterType == FishingWaterSystem.WaterSystemType.Crest);
			platformObjects2.kwsObject.SetActive(waterType == FishingWaterSystem.WaterSystemType.KWS);
		}
		EnableKWSWater(waterType == FishingWaterSystem.WaterSystemType.KWS);
	}

	private void EnableKWSWater(bool enabled)
	{
	}

	public void SetWater(AquariumWaterType waterType)
	{
		_water.noWater.SetActive(waterType == AquariumWaterType.Undefined);
		_water.saltwater.SetActive(waterType == AquariumWaterType.Saltwater);
		_water.freshwater.SetActive(waterType == AquariumWaterType.Freshwater);
	}

	public void SetEnviro(int preset, AquariumWaterType waterType)
	{
		if (waterType == AquariumWaterType.Freshwater)
		{
			for (int i = 0; i < _freshwaterEnvironments.Length; i++)
			{
				_freshwaterEnvironments[i].environment.SetActive(i == preset);
			}
			for (int j = 0; j < _saltwaterEnvironments.Length; j++)
			{
				_saltwaterEnvironments[j].environment.SetActive(false);
			}
		}
		else
		{
			for (int k = 0; k < _saltwaterEnvironments.Length; k++)
			{
				_saltwaterEnvironments[k].environment.SetActive(k == preset);
			}
			for (int l = 0; l < _freshwaterEnvironments.Length; l++)
			{
				_freshwaterEnvironments[l].environment.SetActive(false);
			}
		}
	}

	public WaterProfile GetWaterProfile(int preset, AquariumWaterType waterType)
	{
		if (waterType == AquariumWaterType.Freshwater)
		{
			for (int i = 0; i < _freshwaterEnvironments.Length; i++)
			{
				if (i == preset)
				{
					return _freshwaterEnvironments[i].waterProfile;
				}
			}
		}
		else
		{
			for (int j = 0; j < _saltwaterEnvironments.Length; j++)
			{
				if (j == preset)
				{
					return _saltwaterEnvironments[j].waterProfile;
				}
			}
		}
		return null;
	}

	public void SetAquarium(AquariumSettings settings)
	{
		SetWater(settings.waterType);
		SetEnviro(settings.enviroPreset, settings.waterType);
	}

	public List<string> GetEnvironments(AquariumWaterType waterType)
	{
		List<string> list = new List<string>();
		if (waterType == AquariumWaterType.Freshwater)
		{
			for (int i = 0; i < _freshwaterEnvironments.Length; i++)
			{
				list.Add(Utilities.GetTranslation(_freshwaterEnvironments[i].nameKey));
			}
		}
		else
		{
			for (int j = 0; j < _saltwaterEnvironments.Length; j++)
			{
				list.Add(Utilities.GetTranslation(_saltwaterEnvironments[j].nameKey));
			}
		}
		return list;
	}

	public void OnCameraChanged(bool isUnderwater)
	{
		for (int i = 0; i < _freshwaterEnvironments.Length; i++)
		{
			_freshwaterEnvironments[i].kwsWaterSettings.SetUnderwater(isUnderwater);
		}
		for (int j = 0; j < _saltwaterEnvironments.Length; j++)
		{
			_saltwaterEnvironments[j].kwsWaterSettings.SetUnderwater(isUnderwater);
		}
	}
}