using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("TobaccoPotAndCigar.Runtime")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("TobaccoPotAndCigar.Runtime")]
[assembly: AssemblyTitle("TobaccoPotAndCigar.Runtime")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace TobaccoPotAndCigar.Runtime
{
	public struct CigarEffectTotals
	{
		public float ImmediateSleepPerSecond;

		public float LingeringSleepPerSecond;

		public float WhiteVisualInputPerSecond;

		public float GreenVisualInputPerSecond;

		public float BlackVisualInputPerSecond;
	}
	public static class CigarEffectMath
	{
		public static CigarEffectTotals Calculate(TobaccoBlend blend, float blueImmediateSleepPerSecond, float blueGreenVisualInputPerSecond)
		{
			return new CigarEffectTotals
			{
				ImmediateSleepPerSecond = (float)blend.White * 0.66f - (float)blend.Green * 0.11f + (float)blend.Blue * blueImmediateSleepPerSecond + (float)blend.Black * 1.2f + (float)blend.Brown * 0.8f,
				LingeringSleepPerSecond = (float)blend.White * -0.165f + (float)blend.Green * -0.055f + (float)blend.Blue * -0.055f + (float)blend.Black * -0.3f + (float)blend.Brown * -0.2f,
				WhiteVisualInputPerSecond = (float)blend.White * 2f,
				GreenVisualInputPerSecond = (float)blend.Green * 2f + (float)blend.Blue * blueGreenVisualInputPerSecond,
				BlackVisualInputPerSecond = (float)blend.Black * 2f
			};
		}
	}
	public enum CigarEmberCoolingPhase
	{
		Dark,
		YellowToOrange,
		OrangeToRed,
		RedToDark
	}
	public static class CigarEmberMath
	{
		private const float BoundaryEpsilon = 0.0001f;

		public const float YellowToOrangeSeconds = 2f;

		public const float OrangeToRedSeconds = 12f;

		public const float RedToDarkSeconds = 36f;

		public const float FullHeatCoolingSeconds = 50f;

		public static CigarEmberCoolingPhase GetCoolingPhase(float currentHeat01, float coolingStartHeat01)
		{
			if (currentHeat01 <= 0f || coolingStartHeat01 <= 0f)
			{
				return CigarEmberCoolingPhase.Dark;
			}
			float profileSeconds = GetProfileSeconds(currentHeat01, coolingStartHeat01);
			if (profileSeconds + 0.0001f < 2f)
			{
				return CigarEmberCoolingPhase.YellowToOrange;
			}
			if (profileSeconds + 0.0001f < 14f)
			{
				return CigarEmberCoolingPhase.OrangeToRed;
			}
			return CigarEmberCoolingPhase.RedToDark;
		}

		public static float GetPhaseProgress(CigarEmberCoolingPhase phase, float currentHeat01, float coolingStartHeat01)
		{
			if (currentHeat01 <= 0f || coolingStartHeat01 <= 0f)
			{
				if (phase != CigarEmberCoolingPhase.RedToDark)
				{
					return 0f;
				}
				return 1f;
			}
			float profileSeconds = GetProfileSeconds(currentHeat01, coolingStartHeat01);
			return phase switch
			{
				CigarEmberCoolingPhase.YellowToOrange => Mathf.Clamp01(profileSeconds / 2f), 
				CigarEmberCoolingPhase.OrangeToRed => Mathf.Clamp01((profileSeconds - 2f) / 12f), 
				CigarEmberCoolingPhase.RedToDark => Mathf.Clamp01((profileSeconds - 2f - 12f) / 36f), 
				_ => 0f, 
			};
		}

		public static float GetProfileSeconds(float currentHeat01, float coolingStartHeat01)
		{
			if (coolingStartHeat01 <= 0f)
			{
				return 50f;
			}
			float num = Mathf.Clamp01(currentHeat01 / coolingStartHeat01);
			return (1f - num) * 50f;
		}
	}
	public static class CigarHintText
	{
		public const string GreenHex = "3FAF45";

		public const string BrownHex = "8B5A2B";

		public const string BlueHex = "3F7FFF";

		public const string BlackHex = "202020";

		public static string Build(TobaccoRecipe recipe)
		{
			if (recipe.Count <= 0)
			{
				return "cigar";
			}
			if (recipe.IsFullSingleType)
			{
				return "Full " + GetName(recipe.GetAt(0)) + " Cigar";
			}
			string text = "";
			for (int i = 0; i < recipe.Count; i++)
			{
				text += GetColoredLetter(recipe.GetAt(i));
			}
			return text + " Cigar";
		}

		private static string GetName(CigarTobaccoType tobaccoType)
		{
			return tobaccoType switch
			{
				CigarTobaccoType.White => "White", 
				CigarTobaccoType.Green => "Green", 
				CigarTobaccoType.Black => "Black", 
				CigarTobaccoType.Brown => "Brown", 
				CigarTobaccoType.Blue => "Blue", 
				_ => "Unknown", 
			};
		}

		private static string GetColoredLetter(CigarTobaccoType tobaccoType)
		{
			return tobaccoType switch
			{
				CigarTobaccoType.White => "W", 
				CigarTobaccoType.Green => Color("G", "3FAF45"), 
				CigarTobaccoType.Brown => Color("B", "8B5A2B"), 
				CigarTobaccoType.Blue => Color("B", "3F7FFF"), 
				CigarTobaccoType.Black => Color("B", "202020"), 
				_ => "?", 
			};
		}

		private static string Color(string letter, string hex)
		{
			return "<color=#" + hex + ">" + letter + "</color>";
		}
	}
	public static class CigarValueMath
	{
		public const int WrapperValue = 200;

		public static int Calculate(TobaccoBlend blend, int whiteValue, int greenValue, int blackValue, int brownValue, int blueValue)
		{
			return 200 + blend.White * whiteValue + blend.Green * greenValue + blend.Black * blackValue + blend.Brown * brownValue + blend.Blue * blueValue;
		}

		public static int ScaleByRemainingHealth(int fullValue, float currentHealth, float initialHealth)
		{
			if (fullValue <= 0)
			{
				return 0;
			}
			if (initialHealth <= 0f || float.IsNaN(initialHealth))
			{
				return fullValue;
			}
			if (currentHealth <= 0f || float.IsNaN(currentHealth))
			{
				return 0;
			}
			if (currentHealth >= initialHealth)
			{
				return fullValue;
			}
			double value = (double)fullValue * (double)currentHealth / (double)initialHealth;
			return Math.Max(0, (int)Math.Round(value, MidpointRounding.AwayFromZero));
		}
	}
	public sealed class CigarRuntimeState : MonoBehaviour
	{
		[SerializeField]
		private CigarVisualController cigarVisual;

		private ShipItemPipe pipe;

		private int fullRecipeValue;

		private bool valueInitialized;

		private bool destructionQueued;

		public ShipItemPipe Pipe => pipe;

		private void Awake()
		{
			pipe = ((Component)this).GetComponent<ShipItemPipe>();
			if ((Object)(object)cigarVisual == (Object)null)
			{
				cigarVisual = ((Component)this).GetComponentInChildren<CigarVisualController>(true);
			}
			if ((Object)(object)cigarVisual != (Object)null)
			{
				cigarVisual.BindRoot(pipe);
			}
		}

		private void Start()
		{
			RefreshValue();
			SyncVisuals(snap: true, 0f, inhaling: false);
		}

		public bool TryGetBlend(out TobaccoBlend blend)
		{
			blend = default(TobaccoBlend);
			if (!TryGetRecipe(out var recipe))
			{
				return false;
			}
			blend = recipe.ToBlend();
			return true;
		}

		public bool TryGetRecipe(out TobaccoRecipe recipe)
		{
			recipe = default(TobaccoRecipe);
			bool wasLegacy;
			if ((Object)(object)pipe != (Object)null)
			{
				return TobaccoRecipeCodec.TryDecodeCigar(((ShipItem)pipe).amount, out recipe, out wasLegacy);
			}
			return false;
		}

		public float GetInitialHealth()
		{
			if (!TryGetRecipe(out var recipe))
			{
				return 0f;
			}
			return (float)recipe.Count * 100f;
		}

		public void SyncVisuals(bool snap, float heat01, bool inhaling)
		{
			if ((Object)(object)pipe == (Object)null)
			{
				pipe = ((Component)this).GetComponent<ShipItemPipe>();
			}
			if (!((Object)(object)pipe == (Object)null))
			{
				float initialHealth = GetInitialHealth();
				SyncValueFromHealth(initialHealth);
				if (!((Object)(object)cigarVisual == (Object)null))
				{
					float remaining = ((initialHealth > 0f) ? Mathf.Clamp01(((ShipItem)pipe).health / initialHealth) : 0f);
					cigarVisual.SetRemaining01(remaining, ((ShipItem)pipe).health > 0f && initialHealth > 0f, Mathf.Clamp01(heat01), inhaling, snap);
				}
			}
		}

		public void RefreshValue()
		{
			if ((Object)(object)pipe == (Object)null)
			{
				pipe = ((Component)this).GetComponent<ShipItemPipe>();
			}
			if (!((Object)(object)pipe == (Object)null))
			{
				if (!TryGetRecipe(out var recipe))
				{
					fullRecipeValue = 200;
					valueInitialized = true;
					((GoPointerButton)pipe).description = "cigar";
					SyncValueFromHealth(0f);
				}
				else
				{
					TobaccoBlend blend = recipe.ToBlend();
					fullRecipeValue = CigarValueMath.Calculate(blend, GetPrefabValue(310), GetPrefabValue(312), GetPrefabValue(314), GetPrefabValue(316), GetPrefabValue(318));
					valueInitialized = true;
					((GoPointerButton)pipe).description = CigarHintText.Build(recipe);
					SyncValueFromHealth((float)blend.Count * 100f);
				}
			}
		}

		public bool TryDestroyIfConsumed()
		{
			if (destructionQueued)
			{
				return true;
			}
			if ((Object)(object)pipe == (Object)null)
			{
				pipe = ((Component)this).GetComponent<ShipItemPipe>();
			}
			if ((Object)(object)pipe == (Object)null || ((ShipItem)pipe).health > 0f)
			{
				return false;
			}
			destructionQueued = true;
			((ShipItem)pipe).DestroyItem();
			return true;
		}

		private void SyncValueFromHealth(float initialHealth)
		{
			if (valueInitialized && !((Object)(object)pipe == (Object)null))
			{
				int num = CigarValueMath.ScaleByRemainingHealth(fullRecipeValue, ((ShipItem)pipe).health, initialHealth);
				if (((ShipItem)pipe).value != num)
				{
					((ShipItem)pipe).value = num;
				}
			}
		}

		private static int GetPrefabValue(int prefabIndex)
		{
			PrefabsDirectory instance = PrefabsDirectory.instance;
			if ((Object)(object)instance == (Object)null || instance.directory == null || prefabIndex < 0 || prefabIndex >= instance.directory.Length || (Object)(object)instance.directory[prefabIndex] == (Object)null)
			{
				return 0;
			}
			ShipItem component = instance.directory[prefabIndex].GetComponent<ShipItem>();
			if (!((Object)(object)component != (Object)null))
			{
				return 0;
			}
			return component.value;
		}
	}
	public sealed class CigarVisualController : MonoBehaviour
	{
		private const float BurnVisualLerpSpeed = 12f;

		private const float SpentFrontClearance = 0.008f;

		private const float MinimumPhysicalColliderRatio = 0.05f;

		private const float MinimumPickupLength = 0.04f;

		private const float MaximumEmberLightIntensity = 0.15f;

		private const int IgnoreRaycastLayer = 2;

		private static readonly int ColorProperty = Shader.PropertyToID("_Color");

		private static readonly int EmissionColorProperty = Shader.PropertyToID("_EmissionColor");

		private static readonly Color YellowColor = new Color(1f, 0.42f, 0.025f, 1f);

		private static readonly Color OrangeColor = new Color(0.92f, 0.12f, 0.008f, 1f);

		private static readonly Color YellowEmission = new Color(3.2f, 0.85f, 0.04f, 1f);

		private static readonly Color OrangeEmission = new Color(2.6f, 0.22f, 0.012f, 1f);

		private static readonly Color YellowLightColor = new Color(1f, 0.38f, 0.04f, 1f);

		private static readonly Color OrangeLightColor = new Color(1f, 0.12f, 0.015f, 1f);

		private static readonly Color RedLightColor = new Color(1f, 0.025f, 0.008f, 1f);

		[SerializeField]
		private Transform mouthAnchor;

		[SerializeField]
		private Transform burnableBody;

		[SerializeField]
		private Transform burnFront;

		[SerializeField]
		private GameObject band;

		[SerializeField]
		private Renderer emberRenderer;

		[SerializeField]
		private Light emberLight;

		[SerializeField]
		private BoxCollider rootCollider;

		[SerializeField]
		private BoxCollider pickupCollider;

		[SerializeField]
		private Collider mouthSmokingTrigger;

		private ShipItemPipe pipe;

		private BoxCollider physicalCollider;

		private Vector3 fullBodyScale;

		private Vector3 fullBurnFrontPosition;

		private Vector3 spentBurnFrontPosition;

		private Vector3 fullRootColliderCenter;

		private Vector3 fullRootColliderSize;

		private Vector3 fullPickupColliderCenter;

		private Vector3 fullPickupColliderSize;

		private float rootColliderMouthEndY;

		private float pickupColliderMouthEndY;

		private float burnDirectionSign;

		private float bandThresholdY;

		private float targetRemaining01;

		private float visibleRemaining01;

		private float heat01;

		private float coolingStartHeat01;

		private bool inhaling;

		private bool wasInhaling;

		private bool hasCoolingStartHeat;

		private bool available;

		private bool initialized;

		private MaterialPropertyBlock emberProperties;

		private Color emberBaseColor = Color.white;

		private Color emberBaseEmission = Color.black;

		private void Awake()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Expected O, but got Unknown
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			fullBodyScale = (((Object)(object)burnableBody != (Object)null) ? burnableBody.localScale : Vector3.one);
			fullBurnFrontPosition = (((Object)(object)burnFront != (Object)null) ? burnFront.localPosition : Vector3.zero);
			burnDirectionSign = (((Object)(object)mouthAnchor != (Object)null && (Object)(object)burnFront != (Object)null) ? Mathf.Sign(burnFront.localPosition.y - mouthAnchor.localPosition.y) : 1f);
			if (Mathf.Approximately(burnDirectionSign, 0f))
			{
				burnDirectionSign = 1f;
			}
			spentBurnFrontPosition = fullBurnFrontPosition;
			if ((Object)(object)mouthAnchor != (Object)null)
			{
				spentBurnFrontPosition.y = mouthAnchor.localPosition.y + burnDirectionSign * 0.008f;
			}
			bandThresholdY = (((Object)(object)band != (Object)null) ? band.transform.localPosition.y : spentBurnFrontPosition.y);
			CacheRootColliderGeometry();
			CachePickupColliderGeometry();
			if ((Object)(object)emberRenderer != (Object)null && (Object)(object)emberRenderer.sharedMaterial != (Object)null)
			{
				Material sharedMaterial = emberRenderer.sharedMaterial;
				if (sharedMaterial.HasProperty(ColorProperty))
				{
					emberBaseColor = sharedMaterial.GetColor(ColorProperty);
				}
				if (sharedMaterial.HasProperty(EmissionColorProperty))
				{
					emberBaseEmission = sharedMaterial.GetColor(EmissionColorProperty);
				}
				emberProperties = new MaterialPropertyBlock();
			}
		}

		public void BindRoot(ShipItemPipe newPipe)
		{
			pipe = newPipe;
			SyncInteractionLayers();
			if ((Object)(object)rootCollider == (Object)null && (Object)(object)pipe != (Object)null)
			{
				rootCollider = ((Component)pipe).GetComponent<BoxCollider>();
				CacheRootColliderGeometry();
			}
			CachePickupColliderGeometry();
		}

		public void SetRemaining01(float remaining, bool isAvailable, float newHeat01, bool isInhaling, bool snap)
		{
			targetRemaining01 = Mathf.Clamp01(remaining);
			available = isAvailable;
			heat01 = Mathf.Clamp01(newHeat01);
			UpdateInhaleState(isInhaling, snap);
			if (!available)
			{
				ResetEmberTimeline();
			}
			if (!initialized || snap)
			{
				visibleRemaining01 = targetRemaining01;
				initialized = true;
				ApplyVisualState();
			}
		}

		private void LateUpdate()
		{
			SyncInteractionLayers();
			if (initialized)
			{
				TryBindPhysicalCollider();
				float num = 1f - Mathf.Exp(-12f * Time.deltaTime);
				visibleRemaining01 = Mathf.Lerp(visibleRemaining01, targetRemaining01, num);
				if (Mathf.Abs(visibleRemaining01 - targetRemaining01) < 0.0001f)
				{
					visibleRemaining01 = targetRemaining01;
				}
				ApplyVisualState();
			}
		}

		private void UpdateInhaleState(bool newInhaling, bool snap)
		{
			inhaling = newInhaling;
			if (snap)
			{
				wasInhaling = newInhaling;
				hasCoolingStartHeat = false;
				coolingStartHeat01 = 0f;
			}
			else if (newInhaling)
			{
				wasInhaling = true;
				hasCoolingStartHeat = false;
				coolingStartHeat01 = 0f;
			}
			else if (wasInhaling)
			{
				wasInhaling = false;
				coolingStartHeat01 = heat01;
				hasCoolingStartHeat = coolingStartHeat01 > 0f;
			}
		}

		private void ResetEmberTimeline()
		{
			inhaling = false;
			wasInhaling = false;
			coolingStartHeat01 = 0f;
			hasCoolingStartHeat = false;
		}

		private void SyncInteractionLayers()
		{
			if ((Object)(object)mouthSmokingTrigger != (Object)null && ((Component)mouthSmokingTrigger).gameObject.layer != 2)
			{
				((Component)mouthSmokingTrigger).gameObject.layer = 2;
			}
		}

		private void TryBindPhysicalCollider()
		{
			if (!((Object)(object)physicalCollider != (Object)null) && !((Object)(object)pipe == (Object)null) && !((Object)(object)((ShipItem)pipe).itemRigidbodyC == (Object)null))
			{
				physicalCollider = ((Component)((ShipItem)pipe).itemRigidbodyC).GetComponent<BoxCollider>();
			}
		}

		private void CacheRootColliderGeometry()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)rootCollider == (Object)null))
			{
				fullRootColliderCenter = rootCollider.center;
				fullRootColliderSize = rootCollider.size;
				rootColliderMouthEndY = fullRootColliderCenter.y - burnDirectionSign * fullRootColliderSize.y * 0.5f;
			}
		}

		private void CachePickupColliderGeometry()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)pickupCollider == (Object)null))
			{
				fullPickupColliderCenter = pickupCollider.center;
				fullPickupColliderSize = pickupCollider.size;
				pickupColliderMouthEndY = fullPickupColliderCenter.y - burnDirectionSign * fullPickupColliderSize.y * 0.5f;
			}
		}

		private void ApplyVisualState()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)burnableBody != (Object)null)
			{
				Vector3 localScale = fullBodyScale;
				localScale.y = fullBodyScale.y * visibleRemaining01;
				burnableBody.localScale = localScale;
			}
			if ((Object)(object)burnFront != (Object)null)
			{
				burnFront.localPosition = Vector3.Lerp(spentBurnFrontPosition, fullBurnFrontPosition, visibleRemaining01);
				((Component)burnFront).gameObject.SetActive(available);
			}
			if ((Object)(object)band != (Object)null && (Object)(object)burnFront != (Object)null)
			{
				bool flag = ((burnDirectionSign > 0f) ? (burnFront.localPosition.y > bandThresholdY) : (burnFront.localPosition.y < bandThresholdY));
				band.SetActive(available && flag);
			}
			ApplyPhysicalCollider(rootCollider);
			ApplyPhysicalCollider(physicalCollider);
			ApplyPickupCollider();
			ApplyEmber();
		}

		private void ApplyPhysicalCollider(BoxCollider collider)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)collider == (Object)null) && !(fullRootColliderSize.y <= 0f))
			{
				float num = Mathf.Max(0.05f, visibleRemaining01);
				Vector3 val = fullRootColliderSize;
				val.y = fullRootColliderSize.y * num;
				Vector3 center = fullRootColliderCenter;
				center.y = rootColliderMouthEndY + burnDirectionSign * val.y * 0.5f;
				collider.size = val;
				collider.center = center;
			}
		}

		private void ApplyPickupCollider()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)pickupCollider == (Object)null) && !(fullPickupColliderSize.y <= 0f))
			{
				Vector3 val = fullPickupColliderSize;
				val.y = Mathf.Max(0.04f, fullPickupColliderSize.y * visibleRemaining01);
				Vector3 center = fullPickupColliderCenter;
				center.y = pickupColliderMouthEndY + burnDirectionSign * val.y * 0.5f;
				pickupCollider.size = val;
				pickupCollider.center = center;
			}
		}

		private void ApplyEmber()
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			float num = (available ? heat01 : 0f);
			Color val;
			Color val2;
			Color color;
			if (num > 0f && inhaling)
			{
				val = YellowColor;
				val2 = YellowEmission;
				color = YellowLightColor;
			}
			else
			{
				if (num > 0f && !hasCoolingStartHeat)
				{
					coolingStartHeat01 = num;
					hasCoolingStartHeat = true;
				}
				CigarEmberCoolingPhase coolingPhase = CigarEmberMath.GetCoolingPhase(num, coolingStartHeat01);
				float phaseProgress = CigarEmberMath.GetPhaseProgress(coolingPhase, num, coolingStartHeat01);
				Color val3 = Color.Lerp(Color.black, emberBaseColor, 0.08f);
				switch (coolingPhase)
				{
				case CigarEmberCoolingPhase.YellowToOrange:
					val = Color.Lerp(YellowColor, OrangeColor, phaseProgress);
					val2 = Color.Lerp(YellowEmission, OrangeEmission, phaseProgress);
					color = Color.Lerp(YellowLightColor, OrangeLightColor, phaseProgress);
					break;
				case CigarEmberCoolingPhase.OrangeToRed:
					val = Color.Lerp(OrangeColor, emberBaseColor, phaseProgress);
					val2 = Color.Lerp(OrangeEmission, emberBaseEmission, phaseProgress);
					color = Color.Lerp(OrangeLightColor, RedLightColor, phaseProgress);
					break;
				case CigarEmberCoolingPhase.RedToDark:
					val = Color.Lerp(emberBaseColor, val3, phaseProgress);
					val2 = Color.Lerp(emberBaseEmission, Color.black, phaseProgress);
					color = Color.Lerp(RedLightColor, Color.black, phaseProgress);
					break;
				default:
					val = val3;
					val2 = Color.black;
					color = RedLightColor;
					break;
				}
			}
			if ((Object)(object)emberRenderer != (Object)null && emberProperties != null)
			{
				emberRenderer.GetPropertyBlock(emberProperties);
				emberProperties.SetColor(ColorProperty, val);
				emberProperties.SetColor(EmissionColorProperty, val2);
				emberRenderer.SetPropertyBlock(emberProperties);
			}
			if ((Object)(object)emberLight != (Object)null)
			{
				emberLight.color = color;
				emberLight.intensity = 0.15f * num;
				((Behaviour)emberLight).enabled = num > 0.001f;
			}
		}
	}
	public sealed class DriedTobaccoLeafState : MonoBehaviour
	{
		public const float RolledCigarSpawnHeight = 0.1f;

		[SerializeField]
		private DriedTobaccoLeafVisual leafVisual;

		private ShipItem item;

		public int FillCount
		{
			get
			{
				if (!((Object)(object)item == (Object)null))
				{
					return Mathf.Clamp(Mathf.RoundToInt(item.health), 0, 3);
				}
				return 0;
			}
		}

		public void BindVisual(DriedTobaccoLeafVisual newLeafVisual)
		{
			leafVisual = newLeafVisual;
		}

		private void Awake()
		{
			item = ((Component)this).GetComponent<ShipItem>();
			if ((Object)(object)leafVisual == (Object)null)
			{
				leafVisual = ((Component)this).GetComponentInChildren<DriedTobaccoLeafVisual>(true);
			}
		}

		private void Start()
		{
			SyncFromSavedState();
		}

		public bool TryInsert(ShipItemTobacco tobacco)
		{
			if ((Object)(object)tobacco == (Object)null || !((ShipItem)tobacco).sold || FillCount >= 3)
			{
				return false;
			}
			TobaccoRecipe recipe;
			bool wasLegacy;
			if (FillCount == 0)
			{
				recipe = default(TobaccoRecipe);
			}
			else if (!TobaccoRecipeCodec.TryDecode(Mathf.RoundToInt(item.amount), out recipe, out wasLegacy))
			{
				return false;
			}
			if (!recipe.TryAdd(tobacco))
			{
				return false;
			}
			item.health = recipe.Count;
			item.amount = TobaccoRecipeCodec.Encode(recipe);
			if ((Object)(object)leafVisual != (Object)null)
			{
				leafVisual.SetFillCount(recipe.Count);
			}
			((ShipItem)tobacco).DestroyItem();
			if ((Object)(object)UISoundPlayer.instance != (Object)null)
			{
				UISoundPlayer.instance.PlayUISound((UISounds)4, 0.5f, 0.5f);
			}
			RefreshDescription(recipe.Count);
			return true;
		}

		public bool TryRoll()
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if (!TobaccoRecipeCodec.TryDecode(Mathf.RoundToInt(item.amount), out var recipe, out var _) || recipe.Count != FillCount)
			{
				return false;
			}
			int num = TobaccoRecipeCodec.Encode(recipe);
			return PrefabReplacement.ReplaceOwnedItem(item, 612, 100f * (float)recipe.Count, -num, Vector3.up * 0.1f);
		}

		public void SyncFromSavedState()
		{
			if ((Object)(object)item == (Object)null)
			{
				item = ((Component)this).GetComponent<ShipItem>();
			}
			if ((Object)(object)item == (Object)null)
			{
				return;
			}
			item.health = Mathf.Clamp(Mathf.RoundToInt(item.health), 0, 3);
			TobaccoRecipe recipe;
			bool wasLegacy;
			if (FillCount == 0)
			{
				item.health = 0f;
				item.amount = 0f;
				if ((Object)(object)leafVisual != (Object)null)
				{
					leafVisual.SetFillCount(0);
				}
				((GoPointerButton)item).description = "dried tobacco leaf\nempty (0 / 3)";
			}
			else if (!TobaccoRecipeCodec.TryDecode(Mathf.RoundToInt(item.amount), out recipe, out wasLegacy) || recipe.Count != FillCount)
			{
				RuntimeDiagnostics.Error("Invalid dried-leaf recipe state on instance " + ((Object)this).GetInstanceID() + "; input is disabled until the save is corrected.");
				if ((Object)(object)leafVisual != (Object)null)
				{
					leafVisual.SetFillCount(0);
				}
				((GoPointerButton)item).description = "dried tobacco leaf\ninvalid recipe state";
			}
			else
			{
				if ((Object)(object)leafVisual != (Object)null)
				{
					leafVisual.SetFillCount(recipe.Count);
				}
				RefreshDescription(recipe.Count);
			}
		}

		private void RefreshDescription(int count)
		{
			((GoPointerButton)item).description = "dried tobacco leaf\nfilled: " + count + " / 3\n(R) roll cigar";
		}
	}
	public sealed class DriedTobaccoLeafVisual : MonoBehaviour
	{
		[SerializeField]
		private GameObject fill0Empty;

		[SerializeField]
		private GameObject fill1OneThird;

		[SerializeField]
		private GameObject fill2TwoThirds;

		[SerializeField]
		private GameObject fill3Full;

		public void Configure(GameObject newFill0Empty, GameObject newFill1OneThird, GameObject newFill2TwoThirds, GameObject newFill3Full)
		{
			fill0Empty = newFill0Empty;
			fill1OneThird = newFill1OneThird;
			fill2TwoThirds = newFill2TwoThirds;
			fill3Full = newFill3Full;
		}

		public void SetFillCount(int fillCount)
		{
			fillCount = Mathf.Clamp(fillCount, 0, 3);
			if ((Object)(object)fill0Empty != (Object)null)
			{
				fill0Empty.SetActive(fillCount == 0);
			}
			if ((Object)(object)fill1OneThird != (Object)null)
			{
				fill1OneThird.SetActive(fillCount == 1);
			}
			if ((Object)(object)fill2TwoThirds != (Object)null)
			{
				fill2TwoThirds.SetActive(fillCount == 2);
			}
			if ((Object)(object)fill3Full != (Object)null)
			{
				fill3Full.SetActive(fillCount == 3);
			}
		}
	}
	public sealed class FreshTobaccoLeafState : MonoBehaviour
	{
		[SerializeField]
		private FreshTobaccoLeafVisual leafVisual;

		private ShipItem item;

		private void Awake()
		{
			item = ((Component)this).GetComponent<ShipItem>();
			if ((Object)(object)leafVisual == (Object)null)
			{
				leafVisual = ((Component)this).GetComponentInChildren<FreshTobaccoLeafVisual>(true);
			}
		}

		private void Start()
		{
			SyncDryingVisual();
		}

		public void BindVisual(FreshTobaccoLeafVisual newLeafVisual)
		{
			leafVisual = newLeafVisual;
		}

		public void SyncDryingVisual()
		{
			if ((Object)(object)item == (Object)null)
			{
				item = ((Component)this).GetComponent<ShipItem>();
			}
			if ((Object)(object)item != (Object)null && (Object)(object)leafVisual != (Object)null)
			{
				leafVisual.SetDryingHours(item.health);
			}
		}

		public void RemoveFreshVisualDetails()
		{
			if (!((Object)(object)leafVisual == (Object)null))
			{
				FreshTobaccoLeafVisual freshTobaccoLeafVisual = leafVisual;
				leafVisual = null;
				freshTobaccoLeafVisual.RemoveFreshDetails();
				Object.Destroy((Object)(object)freshTobaccoLeafVisual);
			}
		}
	}
	public sealed class FreshTobaccoLeafVisual : MonoBehaviour
	{
		public const float GameHoursPerDay = 24f;

		public const float WhiteColorGameHours = 72f;

		public const float FullyDriedGameHours = 144f;

		public const int VeinsHiddenPerDay = 2;

		private static readonly int ColorProperty = Shader.PropertyToID("_Color");

		[SerializeField]
		private Renderer bladeRenderer;

		[SerializeField]
		private GameObject[] lateralVeins;

		[SerializeField]
		private GameObject centralMidrib;

		[SerializeField]
		private Renderer[] lateralVeinRenderers;

		[SerializeField]
		private Renderer centralMidribRenderer;

		[SerializeField]
		private Color freshColor = Color.white;

		[SerializeField]
		private Color whiteTobaccoColor = Color.white;

		[SerializeField]
		private Color driedLeafColor = Color.white;

		private MaterialPropertyBlock colorProperties;

		[SerializeField]
		private float[] lateralVeinBrightness;

		[SerializeField]
		private float centralMidribBrightness = 1f;

		private float displayedHours = float.NaN;

		public int LateralVeinCount
		{
			get
			{
				if (lateralVeins == null)
				{
					return 0;
				}
				return lateralVeins.Length;
			}
		}

		private void Awake()
		{
			CacheDetailRenderersAndBrightness(refreshBrightness: false);
		}

		public void Configure(Renderer newBladeRenderer, GameObject[] newLateralVeins, GameObject newCentralMidrib, Color newFreshColor, Color newWhiteTobaccoColor, Color newDriedLeafColor)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			bladeRenderer = newBladeRenderer;
			lateralVeins = newLateralVeins;
			centralMidrib = newCentralMidrib;
			freshColor = newFreshColor;
			whiteTobaccoColor = newWhiteTobaccoColor;
			driedLeafColor = newDriedLeafColor;
			CacheDetailRenderersAndBrightness(refreshBrightness: true);
			displayedHours = float.NaN;
		}

		public void SetDryingHours(float gameHours)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Clamp(gameHours, 0f, 144f);
			if (!float.IsNaN(displayedHours) && Mathf.Abs(displayedHours - num) < 0.0001f)
			{
				return;
			}
			displayedHours = num;
			ApplyColor(EvaluateDryingColor(num, freshColor, whiteTobaccoColor, driedLeafColor));
			int hiddenVeinCount = GetHiddenVeinCount(num, LateralVeinCount);
			for (int i = 0; i < LateralVeinCount; i++)
			{
				if ((Object)(object)lateralVeins[i] != (Object)null)
				{
					lateralVeins[i].SetActive(i >= hiddenVeinCount);
				}
			}
			if ((Object)(object)centralMidrib != (Object)null)
			{
				centralMidrib.SetActive(true);
			}
		}

		public void RemoveFreshDetails()
		{
			if (lateralVeins != null)
			{
				for (int i = 0; i < lateralVeins.Length; i++)
				{
					if ((Object)(object)lateralVeins[i] != (Object)null)
					{
						Object.Destroy((Object)(object)lateralVeins[i]);
					}
				}
			}
			if ((Object)(object)centralMidrib != (Object)null)
			{
				Object.Destroy((Object)(object)centralMidrib);
			}
		}

		public static Color EvaluateDryingColor(float gameHours, Color fresh, Color white, Color dried)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Clamp(gameHours, 0f, 144f);
			if (num <= 72f)
			{
				return Color.Lerp(fresh, white, num / 72f);
			}
			return Color.Lerp(white, dried, (num - 72f) / 72f);
		}

		public static int GetHiddenVeinCount(float gameHours, int veinCount)
		{
			return Mathf.Clamp(Mathf.FloorToInt(Mathf.Max(0f, gameHours) / 24f) * 2, 0, Mathf.Max(0, veinCount));
		}

		private void ApplyColor(Color color)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			if (colorProperties == null)
			{
				colorProperties = new MaterialPropertyBlock();
			}
			ApplyRendererColor(bladeRenderer, color);
			if (lateralVeinRenderers != null)
			{
				for (int i = 0; i < lateralVeinRenderers.Length; i++)
				{
					float brightness = ((lateralVeinBrightness != null && i < lateralVeinBrightness.Length) ? lateralVeinBrightness[i] : 1f);
					ApplyRendererColor(lateralVeinRenderers[i], ApplyBrightness(color, brightness));
				}
			}
			ApplyRendererColor(centralMidribRenderer, ApplyBrightness(color, centralMidribBrightness));
		}

		public static Color ApplyBrightness(Color color, float brightness)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			return new Color(Mathf.Clamp01(color.r * brightness), Mathf.Clamp01(color.g * brightness), Mathf.Clamp01(color.b * brightness), color.a);
		}

		private void ApplyRendererColor(Renderer target, Color color)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)target == (Object)null))
			{
				colorProperties.Clear();
				target.GetPropertyBlock(colorProperties);
				colorProperties.SetColor(ColorProperty, color);
				target.SetPropertyBlock(colorProperties);
			}
		}

		private void CacheDetailRenderersAndBrightness(bool refreshBrightness)
		{
			int lateralVeinCount = LateralVeinCount;
			if (lateralVeinRenderers == null || lateralVeinRenderers.Length != lateralVeinCount)
			{
				lateralVeinRenderers = (Renderer[])(object)new Renderer[lateralVeinCount];
			}
			bool flag = lateralVeinBrightness == null || lateralVeinBrightness.Length != lateralVeinCount;
			if (flag)
			{
				lateralVeinBrightness = new float[lateralVeinCount];
			}
			for (int i = 0; i < lateralVeinCount; i++)
			{
				if ((Object)(object)lateralVeinRenderers[i] == (Object)null && (Object)(object)lateralVeins[i] != (Object)null)
				{
					lateralVeinRenderers[i] = lateralVeins[i].GetComponentInChildren<Renderer>(true);
				}
				if (refreshBrightness || flag)
				{
					lateralVeinBrightness[i] = GetBrightnessRatio(lateralVeinRenderers[i]);
				}
			}
			if ((Object)(object)centralMidribRenderer == (Object)null && (Object)(object)centralMidrib != (Object)null)
			{
				centralMidribRenderer = centralMidrib.GetComponentInChildren<Renderer>(true);
			}
			if (refreshBrightness || flag)
			{
				centralMidribBrightness = GetBrightnessRatio(centralMidribRenderer);
			}
		}

		private float GetBrightnessRatio(Renderer target)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)target == (Object)null || (Object)(object)target.sharedMaterial == (Object)null || !target.sharedMaterial.HasProperty(ColorProperty))
			{
				return 1f;
			}
			Color color = target.sharedMaterial.GetColor(ColorProperty);
			float luminance = GetLuminance(freshColor);
			if (!(luminance > 0.001f))
			{
				return 1f;
			}
			return Mathf.Clamp(GetLuminance(color) / luminance, 0f, 4f);
		}

		private static float GetLuminance(Color color)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			return color.r * 0.2126f + color.g * 0.7152f + color.b * 0.0722f;
		}
	}
	public sealed class RackOnlyDrying : MonoBehaviour
	{
		public const float LooseTobaccoRequiredGameHours = 72f;

		public const float FreshLeafRequiredGameHours = 144f;

		[SerializeField]
		private int resultPrefabIndex;

		private readonly HashSet<DryingRackCol> racks = new HashSet<DryingRackCol>();

		private ShipItem item;

		private Coroutine dryingRoutine;

		public int ResultPrefabIndex => resultPrefabIndex;

		public float CurrentRequiredGameHours => GetRequiredGameHours();

		private void Awake()
		{
			item = ((Component)this).GetComponent<ShipItem>();
		}

		private void Start()
		{
			SyncFromSavedState();
		}

		private void OnDisable()
		{
			StopDrying();
			racks.Clear();
		}

		private void OnTriggerEnter(Collider other)
		{
			RegisterRack(other);
		}

		private void OnTriggerStay(Collider other)
		{
			RegisterRack(other);
		}

		private void OnTriggerExit(Collider other)
		{
			DryingRackCol val = FindRack(other);
			if (!((Object)(object)val == (Object)null) && racks.Remove(val) && racks.Count == 0)
			{
				StopDrying();
			}
		}

		public void ConfigureResultPrefab(int newResultPrefabIndex)
		{
			resultPrefabIndex = newResultPrefabIndex;
		}

		public void SyncFromSavedState()
		{
			if ((Object)(object)item == (Object)null)
			{
				item = ((Component)this).GetComponent<ShipItem>();
			}
			if (!((Object)(object)item == (Object)null))
			{
				item.health = Mathf.Clamp(item.health, 0f, GetRequiredGameHours());
				FreshTobaccoLeafState component = ((Component)item).GetComponent<FreshTobaccoLeafState>();
				if ((Object)(object)component != (Object)null)
				{
					component.SyncDryingVisual();
				}
			}
		}

		private void RegisterRack(Collider other)
		{
			DryingRackCol val = FindRack(other);
			if ((Object)(object)val != (Object)null && racks.Add(val) && dryingRoutine == null)
			{
				dryingRoutine = ((MonoBehaviour)this).StartCoroutine(DryWhileRacked());
			}
		}

		private static DryingRackCol FindRack(Collider other)
		{
			if ((Object)(object)other == (Object)null)
			{
				return null;
			}
			DryingRackCol component = ((Component)other).GetComponent<DryingRackCol>();
			if (!((Object)(object)component != (Object)null))
			{
				return ((Component)other).GetComponentInParent<DryingRackCol>();
			}
			return component;
		}

		private IEnumerator DryWhileRacked()
		{
			while (racks.Count > 0)
			{
				Sun sun = Sun.sun;
				if ((Object)(object)item != (Object)null && item.sold && (Object)(object)sun != (Object)null && !Sun.SunPaused() && resultPrefabIndex > 0)
				{
					float requiredGameHours = GetRequiredGameHours();
					item.health = Mathf.Min(requiredGameHours, item.health + Time.deltaTime * sun.timescale);
					FreshTobaccoLeafState component = ((Component)item).GetComponent<FreshTobaccoLeafState>();
					if ((Object)(object)component != (Object)null)
					{
						component.SyncDryingVisual();
					}
					if (item.health >= requiredGameHours)
					{
						if (TryAdvanceFreshLeafInPlace() || TryAdvanceLooseTobaccoInPlace())
						{
							if (resultPrefabIndex <= 0)
							{
								dryingRoutine = null;
								((Behaviour)this).enabled = false;
								yield break;
							}
							yield return null;
							continue;
						}
						RuntimeDiagnostics.Error("Could not advance rack drying from prefab " + GetCurrentPrefabIndex() + " to " + resultPrefabIndex + " in place. The physical item was preserved; replacement spawning was not attempted.");
						dryingRoutine = null;
						((Behaviour)this).enabled = false;
						yield break;
					}
				}
				yield return null;
			}
			dryingRoutine = null;
		}

		private bool TryAdvanceFreshLeafInPlace()
		{
			FreshTobaccoLeafState freshTobaccoLeafState = (((Object)(object)item != (Object)null) ? ((Component)item).GetComponent<FreshTobaccoLeafState>() : null);
			SaveablePrefab val = (((Object)(object)item != (Object)null) ? ((Component)item).GetComponent<SaveablePrefab>() : null);
			if ((Object)(object)freshTobaccoLeafState == (Object)null || (Object)(object)val == (Object)null || !TobaccoDryingChain.IsStageTransition(val.prefabIndex, resultPrefabIndex))
			{
				return false;
			}
			if (!TryResolveTarget(resultPrefabIndex, out var targetPrefab, out var targetItem, out var targetRenderer) || (Object)(object)targetPrefab.GetComponent<DriedTobaccoLeafState>() == (Object)null)
			{
				return false;
			}
			Renderer component = ((Component)item).GetComponent<Renderer>();
			MeshFilter component2 = ((Component)item).GetComponent<MeshFilter>();
			MeshFilter component3 = targetPrefab.GetComponent<MeshFilter>();
			if ((Object)(object)component == (Object)null || (Object)(object)component2 == (Object)null || (Object)(object)component3 == (Object)null || (Object)(object)component3.sharedMesh == (Object)null)
			{
				return false;
			}
			Transform val2 = CloneDirectChild(targetPrefab.transform, "Fill0_Empty");
			Transform val3 = CloneDirectChild(targetPrefab.transform, "Fill1_OneThird");
			Transform val4 = CloneDirectChild(targetPrefab.transform, "Fill2_TwoThirds");
			Transform val5 = CloneDirectChild(targetPrefab.transform, "Fill3_Full");
			if ((Object)(object)val2 == (Object)null || (Object)(object)val3 == (Object)null || (Object)(object)val4 == (Object)null || (Object)(object)val5 == (Object)null)
			{
				DestroyClone(val2);
				DestroyClone(val3);
				DestroyClone(val4);
				DestroyClone(val5);
				return false;
			}
			component2.sharedMesh = component3.sharedMesh;
			CopyRenderer(component, targetRenderer);
			CopyItemPresentation(item, targetItem);
			item.health = 0f;
			item.amount = 0f;
			val.prefabIndex = resultPrefabIndex;
			((Object)((Component)item).gameObject).name = ((Object)targetPrefab).name + "(Clone)";
			val2.SetParent(((Component)item).transform, false);
			val3.SetParent(((Component)item).transform, false);
			val4.SetParent(((Component)item).transform, false);
			val5.SetParent(((Component)item).transform, false);
			DriedTobaccoLeafVisual driedTobaccoLeafVisual = ((Component)item).gameObject.AddComponent<DriedTobaccoLeafVisual>();
			driedTobaccoLeafVisual.Configure(((Component)val2).gameObject, ((Component)val3).gameObject, ((Component)val4).gameObject, ((Component)val5).gameObject);
			DriedTobaccoLeafState driedTobaccoLeafState = ((Component)item).gameObject.AddComponent<DriedTobaccoLeafState>();
			driedTobaccoLeafState.BindVisual(driedTobaccoLeafVisual);
			driedTobaccoLeafState.SyncFromSavedState();
			if ((Object)(object)item.itemRigidbodyC != (Object)null)
			{
				item.itemRigidbodyC.UpdateMass();
			}
			freshTobaccoLeafState.RemoveFreshVisualDetails();
			Object.Destroy((Object)(object)freshTobaccoLeafState);
			resultPrefabIndex = 0;
			RuntimeDiagnostics.Info("Dried fresh tobacco leaf in place while preserving its collider, rack contact, pose, and save identity.");
			return true;
		}

		private bool TryAdvanceLooseTobaccoInPlace()
		{
			ShipItem obj = item;
			ShipItemTobacco val = (ShipItemTobacco)(object)((obj is ShipItemTobacco) ? obj : null);
			SaveablePrefab val2 = (((Object)(object)item != (Object)null) ? ((Component)item).GetComponent<SaveablePrefab>() : null);
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null || !TobaccoDryingChain.IsStageTransition(val2.prefabIndex, resultPrefabIndex))
			{
				return false;
			}
			if (!TryResolveTarget(resultPrefabIndex, out var targetPrefab, out var targetItem, out var targetRenderer))
			{
				return false;
			}
			ShipItemTobacco val3 = (((Object)(object)targetPrefab != (Object)null) ? targetPrefab.GetComponent<ShipItemTobacco>() : null);
			Renderer component = ((Component)item).GetComponent<Renderer>();
			if ((Object)(object)val3 == (Object)null || (Object)(object)component == (Object)null || (Object)(object)targetRenderer == (Object)null)
			{
				return false;
			}
			int num = resultPrefabIndex;
			CopyRenderer(component, targetRenderer);
			MeshFilter component2 = ((Component)item).GetComponent<MeshFilter>();
			MeshFilter component3 = targetPrefab.GetComponent<MeshFilter>();
			if ((Object)(object)component2 != (Object)null && (Object)(object)component3 != (Object)null)
			{
				component2.sharedMesh = component3.sharedMesh;
			}
			((Object)((Component)item).gameObject).name = ((Object)targetPrefab).name + "(Clone)";
			CopyItemPresentation(item, targetItem);
			item.amount = ((ShipItem)val3).amount;
			item.health = 0f;
			val.tobaccoType = val3.tobaccoType;
			val2.prefabIndex = num;
			if ((Object)(object)item.itemRigidbodyC != (Object)null)
			{
				item.itemRigidbodyC.UpdateMass();
			}
			resultPrefabIndex = (TobaccoDryingChain.TryGetNextStage(num, out var num2) ? num2 : 0);
			RuntimeDiagnostics.Info("Advanced loose tobacco to prefab " + num + " in place while preserving its rack contact and save identity.");
			return true;
		}

		private Transform CloneDirectChild(Transform targetRoot, string childName)
		{
			Transform val = targetRoot.Find(childName);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			GameObject obj = Object.Instantiate<GameObject>(((Component)val).gameObject);
			((Object)obj).name = ((Object)val).name;
			return obj.transform;
		}

		private static void DestroyClone(Transform clone)
		{
			if ((Object)(object)clone != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)clone).gameObject);
			}
		}

		private static bool TryResolveTarget(int prefabIndex, out GameObject targetPrefab, out ShipItem targetItem, out Renderer targetRenderer)
		{
			targetPrefab = null;
			targetItem = null;
			targetRenderer = null;
			PrefabsDirectory instance = PrefabsDirectory.instance;
			if ((Object)(object)instance == (Object)null || instance.directory == null || prefabIndex < 0 || prefabIndex >= instance.directory.Length)
			{
				return false;
			}
			targetPrefab = instance.directory[prefabIndex];
			if ((Object)(object)targetPrefab == (Object)null)
			{
				return false;
			}
			targetItem = targetPrefab.GetComponent<ShipItem>();
			targetRenderer = targetPrefab.GetComponent<Renderer>();
			if ((Object)(object)targetItem != (Object)null)
			{
				return (Object)(object)targetRenderer != (Object)null;
			}
			return false;
		}

		private int GetCurrentPrefabIndex()
		{
			SaveablePrefab val = (((Object)(object)item != (Object)null) ? ((Component)item).GetComponent<SaveablePrefab>() : null);
			if (!((Object)(object)val != (Object)null))
			{
				return -1;
			}
			return val.prefabIndex;
		}

		private float GetRequiredGameHours()
		{
			if (!((Object)(object)item != (Object)null) || !((Object)(object)((Component)item).GetComponent<FreshTobaccoLeafState>() != (Object)null))
			{
				return 72f;
			}
			return 144f;
		}

		private static void CopyRenderer(Renderer target, Renderer source)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			target.sharedMaterials = source.sharedMaterials;
			target.enabled = source.enabled;
			target.shadowCastingMode = source.shadowCastingMode;
			target.receiveShadows = source.receiveShadows;
			target.lightProbeUsage = source.lightProbeUsage;
			target.reflectionProbeUsage = source.reflectionProbeUsage;
		}

		private static void CopyItemPresentation(ShipItem target, ShipItem source)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			target.name = source.name;
			target.mass = source.mass;
			target.value = source.value;
			target.category = source.category;
			target.inventoryScale = source.inventoryScale;
			target.inventoryRotation = source.inventoryRotation;
			target.inventoryRotationX = source.inventoryRotationX;
			target.floaterHeight = source.floaterHeight;
			target.wallAttachment = source.wallAttachment;
			target.delayLook = source.delayLook;
			((PickupableItem)target).big = ((PickupableItem)source).big;
			((PickupableItem)target).holdDistance = ((PickupableItem)source).holdDistance;
			((PickupableItem)target).furniturePlaceHeight = ((PickupableItem)source).furniturePlaceHeight;
			((PickupableItem)target).holdHeight = ((PickupableItem)source).holdHeight;
			((PickupableItem)target).itemClickDistance = ((PickupableItem)source).itemClickDistance;
		}

		private void StopDrying()
		{
			if (dryingRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(dryingRoutine);
				dryingRoutine = null;
			}
		}
	}
	public sealed class TobaccoPlantPotState : MonoBehaviour
	{
		[SerializeField]
		private TobaccoPlantVisual plantVisual;

		private ShipItem item;

		private Coroutine growthRoutine;

		public float StoredWater
		{
			get
			{
				if (!((Object)(object)item == (Object)null))
				{
					return Mathf.Clamp(item.health, 0f, 15f);
				}
				return 0f;
			}
		}

		public float GrowthGameHours
		{
			get
			{
				if (!((Object)(object)item == (Object)null))
				{
					return Mathf.Clamp(item.amount, 0f, 360f);
				}
				return 0f;
			}
		}

		public int CompletedGrowthDays => Mathf.Clamp(Mathf.FloorToInt(GrowthGameHours / 24f), 0, 15);

		public bool FullyGrown => GrowthGameHours >= 360f;

		private void Awake()
		{
			item = ((Component)this).GetComponent<ShipItem>();
			if ((Object)(object)plantVisual == (Object)null)
			{
				plantVisual = ((Component)this).GetComponentInChildren<TobaccoPlantVisual>(true);
			}
		}

		private void Start()
		{
			SyncFromSavedState();
		}

		private void OnEnable()
		{
			if (growthRoutine == null)
			{
				growthRoutine = ((MonoBehaviour)this).StartCoroutine(GrowUsingGameTime());
			}
		}

		private void OnDisable()
		{
			if (growthRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(growthRoutine);
				growthRoutine = null;
			}
		}

		public void SyncFromSavedState()
		{
			if ((Object)(object)item == (Object)null)
			{
				item = ((Component)this).GetComponent<ShipItem>();
			}
			if (!((Object)(object)item == (Object)null))
			{
				item.health = Mathf.Clamp(item.health, 0f, 15f);
				item.amount = Mathf.Clamp(item.amount, 0f, 360f);
				if ((Object)(object)plantVisual != (Object)null)
				{
					plantVisual.SetHarvestReady(FullyGrown);
				}
				RefreshDescription();
			}
		}

		public bool TryAcceptWater(ShipItemBottle source)
		{
			if ((Object)(object)source == (Object)null || !((ShipItem)source).sold || !Mathf.Approximately(((ShipItem)source).amount, 1f) || ((ShipItem)source).health <= 0f || StoredWater >= 15f)
			{
				return false;
			}
			Good component = ((Component)source).GetComponent<Good>();
			if ((Object)(object)component != (Object)null && component.GetMissionIndex() > -1)
			{
				return false;
			}
			float num = Mathf.Min(((ShipItem)source).health, 15f - item.health);
			((ShipItem)source).health = ((ShipItem)source).health - num;
			ShipItem obj = item;
			obj.health += num;
			if (((ShipItem)source).health <= 0f)
			{
				source.EmptyBottle();
			}
			else
			{
				((ShipItem)source).UpdateLookText();
			}
			if ((Object)(object)((ShipItem)source).itemRigidbodyC != (Object)null)
			{
				((ShipItem)source).itemRigidbodyC.UpdateMass();
			}
			if ((Object)(object)UISoundPlayer.instance != (Object)null)
			{
				UISoundPlayer.instance.PlayLiquidPourSound();
			}
			RefreshDescription();
			return true;
		}

		public bool TryHarvest()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			if (!FullyGrown || !PrefabReplacement.CanSpawn(611))
			{
				return false;
			}
			List<ShipItem> list = new List<ShipItem>(2);
			for (int i = 0; i < 2; i++)
			{
				Vector3 val = ((Component)this).transform.right * (((i == 0) ? (-1f) : 1f) * 0.04f);
				ShipItem val2 = PrefabReplacement.SpawnOwned(611, ((Component)this).transform.position + ((Component)this).transform.up * 0.5f + val, ((Component)this).transform.rotation, item, 0f, 0f);
				if ((Object)(object)val2 != (Object)null)
				{
					list.Add(val2);
				}
			}
			if (list.Count != 2)
			{
				for (int j = 0; j < list.Count; j++)
				{
					list[j].DestroyItem();
				}
				RuntimeDiagnostics.Error("Tobacco harvest could not create both leaves; partial output was rolled back and growth was not reset.");
				return false;
			}
			item.amount = 0f;
			SyncFromSavedState();
			return true;
		}

		private IEnumerator GrowUsingGameTime()
		{
			while (true)
			{
				Sun sun = Sun.sun;
				if ((Object)(object)item != (Object)null && item.sold && (Object)(object)sun != (Object)null && !Sun.SunPaused() && !FullyGrown && item.health >= 1f)
				{
					float storedWater = item.health;
					float growthGameHours = item.amount;
					int num = GrowthMath.Advance(ref storedWater, ref growthGameHours, Time.deltaTime * sun.timescale);
					item.health = storedWater;
					item.amount = growthGameHours;
					if (num > 0 || FullyGrown)
					{
						SyncFromSavedState();
					}
				}
				yield return null;
			}
		}

		private void RefreshDescription()
		{
			if (!((Object)(object)item == (Object)null))
			{
				((GoPointerButton)item).description = (FullyGrown ? ("tobacco pot\nfully grown\nwater: " + item.health.ToString("0") + " / 15\n(R) harvest") : ("tobacco pot\ngrowth: " + CompletedGrowthDays + " / 15 days\nwater: " + item.health.ToString("0") + " / 15"));
			}
		}
	}
	public sealed class TobaccoPlantVisual : MonoBehaviour
	{
		[SerializeField]
		private GameObject plantBase;

		[SerializeField]
		private GameObject harvestLeaves;

		public void SetHarvestReady(bool ready)
		{
			if ((Object)(object)plantBase != (Object)null && !plantBase.activeSelf)
			{
				plantBase.SetActive(true);
			}
			if ((Object)(object)harvestLeaves != (Object)null)
			{
				harvestLeaves.SetActive(ready);
			}
		}
	}
	public static class GrowthMath
	{
		public const float Capacity = 15f;

		public const float GameHoursPerDay = 24f;

		public const int RequiredDays = 15;

		public const float RequiredGameHours = 360f;

		public static int Advance(ref float storedWater, ref float growthGameHours, float availableGameHours)
		{
			storedWater = Mathf.Clamp(storedWater, 0f, 15f);
			growthGameHours = Mathf.Clamp(growthGameHours, 0f, 360f);
			availableGameHours = Mathf.Max(0f, availableGameHours);
			int num = 0;
			while (availableGameHours > 1E-05f && storedWater >= 1f && growthGameHours < 360f)
			{
				float num2 = Mathf.Min((float)(Mathf.FloorToInt(growthGameHours / 24f) + 1) * 24f, 360f);
				float num3 = Mathf.Min(availableGameHours, num2 - growthGameHours);
				if (num3 <= 0f)
				{
					break;
				}
				growthGameHours += num3;
				availableGameHours -= num3;
				if (growthGameHours >= num2 - 0.0001f)
				{
					growthGameHours = num2;
					storedWater = Mathf.Max(0f, storedWater - 1f);
					num++;
				}
			}
			return num;
		}
	}
	public static class PrefabReplacement
	{
		private static readonly GameObject[] CustomPrefabs = (GameObject[])(object)new GameObject[4];

		public static void RegisterCustomPrefab(int index, GameObject prefab)
		{
			int num = index - 610;
			if (num < 0 || num >= CustomPrefabs.Length)
			{
				throw new ArgumentOutOfRangeException("index");
			}
			CustomPrefabs[num] = prefab;
		}

		public static void ClearCustomPrefabs()
		{
			for (int i = 0; i < CustomPrefabs.Length; i++)
			{
				CustomPrefabs[i] = null;
			}
		}

		public static bool CanSpawn(int prefabIndex)
		{
			if ((Object)(object)ResolvePrefab(prefabIndex) != (Object)null)
			{
				return (Object)(object)SaveLoadManager.instance != (Object)null;
			}
			return false;
		}

		public static ShipItem SpawnOwned(int prefabIndex, Vector3 position, Quaternion rotation, ShipItem context, float health, float amount)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = ResolvePrefab(prefabIndex);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			if ((Object)(object)SaveLoadManager.instance == (Object)null)
			{
				RuntimeDiagnostics.Error("Cannot spawn prefab " + prefabIndex + ": SaveLoadManager is unavailable.");
				return null;
			}
			GameObject val2 = Object.Instantiate<GameObject>(val, position, rotation);
			ShipItem component = val2.GetComponent<ShipItem>();
			SaveablePrefab component2 = val2.GetComponent<SaveablePrefab>();
			if ((Object)(object)component == (Object)null || (Object)(object)component2 == (Object)null)
			{
				RuntimeDiagnostics.Error("Registered prefab " + prefabIndex + " lost its ShipItem/SaveablePrefab contract.");
				Object.Destroy((Object)(object)val2);
				return null;
			}
			if ((Object)(object)context != (Object)null)
			{
				SaveablePrefab component3 = ((Component)context).GetComponent<SaveablePrefab>();
				if ((Object)(object)component3 != (Object)null)
				{
					component2.SetParentObject(component3.GetParentObject());
					component2.currentCrateId = component3.currentCrateId;
				}
				if ((Object)(object)((Component)context).transform.parent != (Object)null)
				{
					val2.transform.SetParent(((Component)context).transform.parent, true);
				}
			}
			component.sold = true;
			component.health = health;
			component.amount = amount;
			RuntimeStateSynchronizer.Sync(component, snapCigar: true);
			component2.RegisterToSave();
			return component;
		}

		public static bool ReplaceOwnedItem(ShipItem source, int resultPrefabIndex, float replacementHealth, float replacementAmount)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			return ReplaceOwnedItem(source, resultPrefabIndex, replacementHealth, replacementAmount, Vector3.zero);
		}

		public static bool ReplaceOwnedItem(ShipItem source, int resultPrefabIndex, float replacementHealth, float replacementAmount, Vector3 worldPositionOffset)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (!CanTransform(source))
			{
				return false;
			}
			if ((Object)(object)SpawnOwned(resultPrefabIndex, ((Component)source).transform.position + worldPositionOffset, ((Component)source).transform.rotation, source, replacementHealth, replacementAmount) == (Object)null)
			{
				return false;
			}
			if ((Object)(object)source.itemRigidbodyC != (Object)null)
			{
				source.FreezeItem();
			}
			else
			{
				Collider component = ((Component)source).GetComponent<Collider>();
				if ((Object)(object)component != (Object)null)
				{
					component.enabled = false;
				}
			}
			source.DestroyItem();
			return true;
		}

		private static bool CanTransform(ShipItem source)
		{
			if ((Object)(object)source == (Object)null || !source.sold)
			{
				return false;
			}
			SaveablePrefab component = ((Component)source).GetComponent<SaveablePrefab>();
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			if (component.currentCrateId > 0)
			{
				RuntimeDiagnostics.Error("Refusing to transform crate-contained item " + source.name + ".");
				return false;
			}
			if ((Object)(object)source.itemRigidbodyC != (Object)null && source.GetCurrentInventorySlot() >= 0)
			{
				RuntimeDiagnostics.Error("Refusing to transform inventory-held item " + source.name + ".");
				return false;
			}
			return true;
		}

		private static GameObject ResolvePrefab(int prefabIndex)
		{
			PrefabsDirectory instance = PrefabsDirectory.instance;
			if ((Object)(object)instance == (Object)null || instance.directory == null || prefabIndex < 0 || prefabIndex >= instance.directory.Length)
			{
				RuntimeDiagnostics.Error("Prefab directory cannot resolve index " + prefabIndex + ".");
				return null;
			}
			GameObject val = instance.directory[prefabIndex];
			int num = prefabIndex - 610;
			if (num >= 0 && num < CustomPrefabs.Length && (Object)(object)val != (Object)(object)CustomPrefabs[num])
			{
				RuntimeDiagnostics.Error("Custom prefab index " + prefabIndex + " is not the registered bundled asset.");
				return null;
			}
			return val;
		}
	}
	public static class RuntimeConstants
	{
		public const int FirstVanillaPipePrefabIndex = 300;

		public const int LastVanillaPipePrefabIndex = 302;

		public const int TobaccoPotPrefabIndex = 610;

		public const int FreshTobaccoLeafPrefabIndex = 611;

		public const int CigarPrefabIndex = 612;

		public const int DriedTobaccoLeafPrefabIndex = 613;

		public const int WhiteTobaccoPrefabIndex = 310;

		public const int GreenTobaccoPrefabIndex = 312;

		public const int BlackTobaccoPrefabIndex = 314;

		public const int BrownTobaccoPrefabIndex = 316;

		public const int BlueTobaccoPrefabIndex = 318;
	}
	public static class RuntimeDiagnostics
	{
		public static Action<string> InfoSink;

		public static Action<string> WarningSink;

		public static Action<string> ErrorSink;

		public static void Info(string message)
		{
			if (InfoSink != null)
			{
				InfoSink(message);
			}
			else
			{
				Debug.Log((object)("Tobacco pot and cigar: " + message));
			}
		}

		public static void Warning(string message)
		{
			if (WarningSink != null)
			{
				WarningSink(message);
			}
			else
			{
				Debug.LogWarning((object)("Tobacco pot and cigar: " + message));
			}
		}

		public static void Error(string message)
		{
			if (ErrorSink != null)
			{
				ErrorSink(message);
			}
			else
			{
				Debug.LogError((object)("Tobacco pot and cigar: " + message));
			}
		}

		public static void Reset()
		{
			InfoSink = null;
			WarningSink = null;
			ErrorSink = null;
		}
	}
	public static class RuntimeStateSynchronizer
	{
		public static void Sync(ShipItem item, bool snapCigar)
		{
			if (!((Object)(object)item == (Object)null))
			{
				TobaccoPlantPotState component = ((Component)item).GetComponent<TobaccoPlantPotState>();
				if ((Object)(object)component != (Object)null)
				{
					component.SyncFromSavedState();
				}
				RackOnlyDrying component2 = ((Component)item).GetComponent<RackOnlyDrying>();
				if ((Object)(object)component2 != (Object)null)
				{
					component2.SyncFromSavedState();
				}
				DriedTobaccoLeafState component3 = ((Component)item).GetComponent<DriedTobaccoLeafState>();
				if ((Object)(object)component3 != (Object)null)
				{
					component3.SyncFromSavedState();
				}
				CigarRuntimeState component4 = ((Component)item).GetComponent<CigarRuntimeState>();
				if ((Object)(object)component4 != (Object)null && !component4.TryDestroyIfConsumed())
				{
					component4.RefreshValue();
					component4.SyncVisuals(snapCigar, 0f, inhaling: false);
				}
			}
		}
	}
	public enum CigarTobaccoType
	{
		White = 1,
		Green,
		Black,
		Brown,
		Blue
	}
	public struct TobaccoBlend
	{
		public int White;

		public int Green;

		public int Black;

		public int Brown;

		public int Blue;

		public int Count => White + Green + Black + Brown + Blue;

		public bool TryAdd(ShipItemTobacco tobacco)
		{
			if (TobaccoTypeResolver.TryResolve(tobacco, out var tobaccoType))
			{
				return TryAdd(tobaccoType);
			}
			return false;
		}

		public bool TryAdd(CigarTobaccoType tobaccoType)
		{
			if (Count >= 3)
			{
				return false;
			}
			switch (tobaccoType)
			{
			case CigarTobaccoType.White:
				White++;
				return true;
			case CigarTobaccoType.Green:
				Green++;
				return true;
			case CigarTobaccoType.Black:
				Black++;
				return true;
			case CigarTobaccoType.Brown:
				Brown++;
				return true;
			case CigarTobaccoType.Blue:
				Blue++;
				return true;
			default:
				return false;
			}
		}
	}
	public static class TobaccoBlendCodec
	{
		public static int Encode(TobaccoBlend blend)
		{
			if (blend.Count < 1 || blend.Count > 3 || blend.White < 0 || blend.White > 3 || blend.Green < 0 || blend.Green > 3 || blend.Black < 0 || blend.Black > 3 || blend.Brown < 0 || blend.Brown > 3 || blend.Blue < 0 || blend.Blue > 3)
			{
				throw new ArgumentOutOfRangeException("blend");
			}
			return 1 + blend.White + (blend.Green << 2) + (blend.Black << 4) + (blend.Brown << 6) + (blend.Blue << 8);
		}

		public static bool TryDecode(int code, out TobaccoBlend blend)
		{
			if (TobaccoRecipeCodec.TryDecodeOrdered(code, out var recipe))
			{
				blend = recipe.ToBlend();
				return true;
			}
			return TryDecodeLegacy(code, out blend);
		}

		internal static bool TryDecodeLegacy(int code, out TobaccoBlend blend)
		{
			blend = default(TobaccoBlend);
			if (code <= 0 || code >= 4096)
			{
				return false;
			}
			int num = code - 1;
			blend.White = num & 3;
			blend.Green = (num >> 2) & 3;
			blend.Black = (num >> 4) & 3;
			blend.Brown = (num >> 6) & 3;
			blend.Blue = (num >> 8) & 3;
			int num2 = 1023;
			if ((num & ~num2) == 0 && blend.Count >= 1)
			{
				return blend.Count <= 3;
			}
			return false;
		}

		public static bool TryDecodeCigar(float itemAmount, out TobaccoBlend blend)
		{
			blend = default(TobaccoBlend);
			int num = Mathf.RoundToInt(itemAmount);
			if (num < 0)
			{
				return TryDecode(-num, out blend);
			}
			return false;
		}
	}
	public static class TobaccoDryingChain
	{
		public static bool TryGetNextStage(int sourcePrefabIndex, out int resultPrefabIndex)
		{
			switch (sourcePrefabIndex)
			{
			case 611:
				resultPrefabIndex = 613;
				return true;
			case 312:
				resultPrefabIndex = 310;
				return true;
			case 310:
				resultPrefabIndex = 316;
				return true;
			case 316:
				resultPrefabIndex = 314;
				return true;
			default:
				resultPrefabIndex = 0;
				return false;
			}
		}

		public static bool IsStageTransition(int sourcePrefabIndex, int resultPrefabIndex)
		{
			if (TryGetNextStage(sourcePrefabIndex, out var resultPrefabIndex2))
			{
				return resultPrefabIndex2 == resultPrefabIndex;
			}
			return false;
		}
	}
	public struct TobaccoRecipe
	{
		private CigarTobaccoType first;

		private CigarTobaccoType second;

		private CigarTobaccoType third;

		private int count;

		public int Count => count;

		public bool IsFullSingleType
		{
			get
			{
				if (count == 3 && first == second)
				{
					return second == third;
				}
				return false;
			}
		}

		public CigarTobaccoType GetAt(int index)
		{
			switch (index)
			{
			case 0:
				if (count > 0)
				{
					return first;
				}
				break;
			case 1:
				if (count > 1)
				{
					return second;
				}
				break;
			case 2:
				if (count > 2)
				{
					return third;
				}
				break;
			}
			throw new ArgumentOutOfRangeException("index");
		}

		public bool TryAdd(CigarTobaccoType tobaccoType)
		{
			if (count >= 3 || !TobaccoTypeResolver.IsSupported(tobaccoType))
			{
				return false;
			}
			if (count == 0)
			{
				first = tobaccoType;
			}
			else if (count == 1)
			{
				second = tobaccoType;
			}
			else
			{
				third = tobaccoType;
			}
			count++;
			return true;
		}

		public bool TryAdd(ShipItemTobacco tobacco)
		{
			if (TobaccoTypeResolver.TryResolve(tobacco, out var tobaccoType))
			{
				return TryAdd(tobaccoType);
			}
			return false;
		}

		public TobaccoBlend ToBlend()
		{
			TobaccoBlend result = default(TobaccoBlend);
			for (int i = 0; i < count; i++)
			{
				result.TryAdd(GetAt(i));
			}
			return result;
		}

		internal static TobaccoRecipe FromLegacyBlend(TobaccoBlend blend)
		{
			TobaccoRecipe recipe = default(TobaccoRecipe);
			AddCopies(ref recipe, CigarTobaccoType.Green, blend.Green);
			AddCopies(ref recipe, CigarTobaccoType.White, blend.White);
			AddCopies(ref recipe, CigarTobaccoType.Brown, blend.Brown);
			AddCopies(ref recipe, CigarTobaccoType.Blue, blend.Blue);
			AddCopies(ref recipe, CigarTobaccoType.Black, blend.Black);
			return recipe;
		}

		private static void AddCopies(ref TobaccoRecipe recipe, CigarTobaccoType tobaccoType, int copies)
		{
			for (int i = 0; i < copies; i++)
			{
				recipe.TryAdd(tobaccoType);
			}
		}
	}
	public static class TobaccoRecipeCodec
	{
		public const int OrderedRecipeMarker = 4096;

		private const int Radix = 6;

		private const int MaximumPayload = 216;

		public static int Encode(TobaccoRecipe recipe)
		{
			if (recipe.Count < 1 || recipe.Count > 3)
			{
				throw new ArgumentOutOfRangeException("recipe");
			}
			int num = 0;
			int num2 = 1;
			for (int i = 0; i < recipe.Count; i++)
			{
				num += (int)recipe.GetAt(i) * num2;
				num2 *= 6;
			}
			return 4096 + num;
		}

		public static bool TryDecode(int code, out TobaccoRecipe recipe, out bool wasLegacy)
		{
			wasLegacy = false;
			if (TryDecodeOrdered(code, out recipe))
			{
				return true;
			}
			if (!TobaccoBlendCodec.TryDecodeLegacy(code, out var blend))
			{
				recipe = default(TobaccoRecipe);
				return false;
			}
			recipe = TobaccoRecipe.FromLegacyBlend(blend);
			wasLegacy = true;
			return recipe.Count == blend.Count;
		}

		public static bool TryDecodeCigar(float itemAmount, out TobaccoRecipe recipe, out bool wasLegacy)
		{
			recipe = default(TobaccoRecipe);
			wasLegacy = false;
			int num = Mathf.RoundToInt(itemAmount);
			if (num < 0)
			{
				return TryDecode(-num, out recipe, out wasLegacy);
			}
			return false;
		}

		internal static bool TryDecodeOrdered(int code, out TobaccoRecipe recipe)
		{
			recipe = default(TobaccoRecipe);
			int num = code - 4096;
			if (num <= 0 || num >= 216)
			{
				return false;
			}
			int num2 = num % 6;
			int num3 = num / 6 % 6;
			int num4 = num / 36 % 6;
			if (!IsValidDigit(num2) || (num3 == 0 && num4 != 0) || (num3 != 0 && !IsValidDigit(num3)) || (num4 != 0 && !IsValidDigit(num4)))
			{
				return false;
			}
			recipe.TryAdd((CigarTobaccoType)num2);
			if (num3 != 0)
			{
				recipe.TryAdd((CigarTobaccoType)num3);
			}
			if (num4 != 0)
			{
				recipe.TryAdd((CigarTobaccoType)num4);
			}
			return true;
		}

		private static bool IsValidDigit(int value)
		{
			if (value >= 1)
			{
				return value <= 5;
			}
			return false;
		}
	}
	public static class TobaccoTypeResolver
	{
		public static bool TryResolve(ShipItemTobacco tobacco, out CigarTobaccoType tobaccoType)
		{
			tobaccoType = (CigarTobaccoType)0;
			if ((Object)(object)tobacco == (Object)null)
			{
				return false;
			}
			SaveablePrefab component = ((Component)tobacco).GetComponent<SaveablePrefab>();
			if (((Object)(object)component != (Object)null && component.prefabIndex == 318) || tobacco.tobaccoType == 5)
			{
				tobaccoType = CigarTobaccoType.Blue;
				return true;
			}
			tobaccoType = (CigarTobaccoType)tobacco.tobaccoType;
			return IsSupported(tobaccoType);
		}

		public static bool IsSupported(CigarTobaccoType tobaccoType)
		{
			if (tobaccoType >= CigarTobaccoType.White)
			{
				return tobaccoType <= CigarTobaccoType.Blue;
			}
			return false;
		}
	}
}