using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Rendering;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("PrimeForestSpirit")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.4.2.0")]
[assembly: AssemblyInformationalVersion("0.4.2")]
[assembly: AssemblyProduct("PrimeForestSpirit")]
[assembly: AssemblyTitle("PrimeForestSpirit")]
[assembly: AssemblyVersion("0.4.2.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 BiomeRevival.PrimeForestSpirit
{
	[BepInPlugin("com.prime.forestspirit", "Prime Forest Spirit", "0.4.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public sealed class PrimeForestSpiritPlugin : BaseUnityPlugin
	{
		public const string PluginId = "com.prime.forestspirit";

		public const string PrefabName = "PrimeForestSpirit";

		internal static PrimeForestSpiritPlugin Instance;

		internal static SpiritSettings Settings;

		public static Func<bool> RestorationGate;

		private SpiritVisuals visuals;

		private void Awake()
		{
			Instance = this;
			Settings = new SpiritSettings(((BaseUnityPlugin)this).Config);
			PrefabManager.OnVanillaPrefabsAvailable += Register;
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Prime Forest Spirit 0.4.2: original visuals/movement/lifetime; nighttime restored visibility, sleeping offscreen/daytime visuals and lights.");
		}

		private void Register()
		{
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			PrefabManager.OnVanillaPrefabsAvailable -= Register;
			GameObject val = null;
			try
			{
				GameObject prefab = PrefabManager.Instance.GetPrefab("LuredWisp");
				if (!Object.op_Implicit((Object)(object)prefab))
				{
					throw new InvalidOperationException("Installed LuredWisp prefab was not available.");
				}
				if (Object.op_Implicit((Object)(object)PrefabManager.Instance.GetPrefab("PrimeForestSpirit")))
				{
					throw new InvalidOperationException("Prefab name already registered: PrimeForestSpirit");
				}
				val = PrefabManager.Instance.CreateEmptyPrefab("PrimeForestSpirit", false);
				if (!Object.op_Implicit((Object)(object)val) || val.activeInHierarchy)
				{
					throw new InvalidOperationException("Expected an inactive Jotunn prefab container; refusing unsafe construction.");
				}
				val.SetActive(false);
				Component[] components = val.GetComponents<Component>();
				foreach (Component val2 in components)
				{
					if (!(val2 is Transform))
					{
						Object.DestroyImmediate((Object)(object)val2);
					}
				}
				val.layer = LayerMask.NameToLayer("Default");
				val.tag = "spawned";
				visuals = new SpiritVisuals(Settings, ((BaseUnityPlugin)this).Logger);
				visuals.Build(prefab, val);
				ZNetView obj = val.AddComponent<ZNetView>();
				obj.m_persistent = true;
				obj.m_distant = false;
				obj.m_type = (ObjectType)0;
				obj.m_syncInitialScale = false;
				ZSyncTransform obj2 = val.AddComponent<ZSyncTransform>();
				obj2.m_syncPosition = true;
				obj2.m_syncRotation = false;
				obj2.m_syncScale = false;
				obj2.m_syncBodyVelocity = false;
				obj2.m_characterParentSync = false;
				val.AddComponent<SpiritWander>();
				val.AddComponent<FireflyPulse>();
				val.AddComponent<FireflyVisibility>();
				val.AddComponent<SpiritLifetime>();
				SpiritVisuals.Validate(val);
				val.SetActive(true);
				PrefabManager.Instance.AddPrefab(val);
				((BaseUnityPlugin)this).Logger.LogInfo((object)("REGISTERED PrimeForestSpirit: luminous point/halo at " + Settings.Scale + " scale, light=" + Settings.LightIntensity + "/" + Settings.LightRange + ", materials=" + visuals.MaterialCount + ", owner-controlled wandering. No interaction/combat/mist components."));
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("PrimeForestSpirit registration failed; no spawning enabled: " + ex));
				if (Object.op_Implicit((Object)(object)val))
				{
					Object.Destroy((Object)(object)val);
				}
			}
		}

		internal void Diagnostic(string message)
		{
			if (Settings.Diagnostics)
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)message);
			}
		}

		private void OnDestroy()
		{
			PrefabManager.OnVanillaPrefabsAvailable -= Register;
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}
	}
	internal sealed class SpiritSettings
	{
		internal readonly float Scale;

		internal readonly float LightIntensity;

		internal readonly float LightRange;

		internal readonly float LightDistance;

		internal readonly Color FireflyColor;

		internal readonly float CoreDiameter;

		internal readonly float HaloDiameter;

		internal readonly float CoreBrightness;

		internal readonly float HaloBrightness;

		internal readonly float CoreOpacity;

		internal readonly float HaloOpacity;

		internal readonly float PulseMinSeconds;

		internal readonly float PulseMaxSeconds;

		internal readonly float PulseMinimum;

		internal readonly float VisualDistance;

		internal readonly float VisibilityInterval;

		internal readonly float VisibilityHysteresis;

		internal readonly float Radius;

		internal readonly float Speed;

		internal readonly float Steering;

		internal readonly float PauseChance;

		internal readonly float PauseMin;

		internal readonly float PauseMax;

		internal readonly float LegMin;

		internal readonly float LegMax;

		internal readonly float HoverHeight;

		internal readonly float BobAmplitude;

		internal readonly float BobPeriod;

		internal readonly float SurfaceInterval;

		internal readonly float ObstacleRadius;

		internal readonly float ObstacleDistance;

		internal readonly float CurveRate;

		internal readonly float SurfaceResponse;

		internal readonly float AvoidanceResponse;

		internal readonly float RenderResponse;

		internal readonly bool Diagnostics;

		internal SpiritSettings(ConfigFile config)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			Scale = Number(config, "Visuals", "VisualScale", 1f, 0.1f, 1f, "Scale relative to LuredWisp, including particles. Restart required for settings changes.");
			Color value = config.Bind<Color>("Firefly", "FireflyColor", new Color(1f, 0.68f, 0.18f, 1f), "Warm golden-yellow tint shared by core, halo and light. Replaces old GoldColor; restart required.").Value;
			FireflyColor = new Color(Mathf.Clamp01(value.r), Mathf.Clamp01(value.g), Mathf.Clamp01(value.b), 1f);
			LightIntensity = Number(config, "Visuals", "LightIntensity", 0.8f, 0f, 2f, "Point-light intensity; zero removes scene illumination but preserves the emissive glow.");
			LightRange = Number(config, "Visuals", "LightRange", 3f, 0.1f, 5f, "Point-light range in metres; no shadows.");
			LightDistance = Number(config, "Visuals", "LightCullDistance", 15f, 2f, 40f, "Vanilla LightLod distance in metres.");
			CoreDiameter = Number(config, "Firefly", "CoreDiameter", 0.055f, 0.01f, 0.2f, "Luminous billboard core diameter in metres at VisualScale=1; no solid mesh.");
			HaloDiameter = Number(config, "Firefly", "HaloDiameter", 0.45f, 0.1f, 1.5f, "Soft radial halo diameter in metres at VisualScale=1.");
			CoreBrightness = Number(config, "Firefly", "CoreBrightness", 2f, 0.1f, 5f, "Peak unlit core RGB multiplier; appearance depends on tone mapping/bloom.");
			HaloBrightness = Number(config, "Firefly", "HaloBrightness", 1f, 0.1f, 3f, "Peak unlit halo RGB multiplier.");
			CoreOpacity = Number(config, "Firefly", "CoreOpacity", 0.85f, 0.05f, 1f, "Core peak alpha before smooth pulse modulation.");
			HaloOpacity = Number(config, "Firefly", "HaloOpacity", 0.22f, 0.01f, 0.8f, "Halo peak alpha; procedural alpha fades smoothly to zero at its edge.");
			PulseMinSeconds = Number(config, "Firefly", "PulsePeriodMinSeconds", 2f, 0.5f, 20f, "Minimum individual pulse period; stable per-object randomization.");
			PulseMaxSeconds = Mathf.Max(PulseMinSeconds, Number(config, "Firefly", "PulsePeriodMaxSeconds", 4f, 0.5f, 30f, "Maximum individual pulse period."));
			PulseMinimum = Number(config, "Firefly", "PulseMinimumBrightness", 0.08f, 0f, 0.5f, "Dim-phase fraction of peak; modulates core/halo alpha and point-light intensity together.");
			VisualDistance = Number(config, "Visibility", "VisualDistance", 80f, 20f, 120f, "Glow-only camera distance in metres, subject to native object loading/fog/occlusion. Does not expand illumination or global draw distances.");
			VisibilityInterval = Number(config, "Visibility", "CheckIntervalSeconds", 0.25f, 0.1f, 1f, "Local per-object camera-distance check interval; no scene scan.");
			VisibilityHysteresis = Number(config, "Visibility", "HysteresisMetres", 2f, 0f, 10f, "Extra distance before hiding a currently visible glow, preventing edge toggling.");
			Radius = Number(config, "Movement", "WanderRadius", 10f, 1f, 50f, "Horizontal roaming radius around the original network spawn position, with smooth edge steering.");
			Speed = Number(config, "Movement", "MoveSpeed", 1.05f, 0.05f, 2f, "Maximum horizontal speed in metres per second; v0.2 default is 1.75x the v0.1 default.");
			Steering = Number(config, "Movement", "SteeringRate", 1.2f, 0.1f, 5f, "Velocity easing rate; smaller values give gentler turns.");
			CurveRate = Number(config, "Movement", "CurveAngularRate", 0.18f, 0.02f, 0.6f, "Angular rate of the continuously moving two-orbit attractor; no waypoint arrivals.");
			SurfaceResponse = Number(config, "Movement", "SurfaceResponse", 2.5f, 0.2f, 10f, "Per-frame filtering of sampled surface heights and vertical speed response.");
			AvoidanceResponse = Number(config, "Movement", "AvoidanceResponse", 3f, 0.2f, 10f, "Per-frame filtering of occasional obstacle samples.");
			RenderResponse = Number(config, "Movement", "RenderResponse", 12f, 2f, 30f, "LateUpdate visual-position smoothing rate on all peers; root synchronization remains native.");
			PauseChance = Number(config, "Movement", "PauseChance", 0.4f, 0f, 1f, "Chance of pausing after a wander leg.");
			PauseMin = Number(config, "Movement", "PauseMinSeconds", 1.5f, 0.1f, 30f, "Minimum pause duration.");
			PauseMax = Mathf.Max(PauseMin, Number(config, "Movement", "PauseMaxSeconds", 4.5f, 0.1f, 60f, "Maximum pause duration."));
			LegMin = Number(config, "Movement", "DirectionMinSeconds", 7f, 1f, 60f, "Minimum cruising time before a pause opportunity; no abrupt direction change occurs.");
			LegMax = Mathf.Max(LegMin, Number(config, "Movement", "DirectionMaxSeconds", 16f, 1f, 120f, "Maximum cruising time before a pause opportunity."));
			BobAmplitude = Number(config, "Movement", "BobAmplitude", 0.1f, 0f, 0.4f, "Maximum child-visual vertical bob in metres.");
			BobPeriod = Number(config, "Movement", "BobPeriodSeconds", 4f, 1f, 15f, "Main bob period, combined with a second slower oscillation.");
			HoverHeight = Mathf.Max(BobAmplitude + 0.2f, Number(config, "Movement", "HoverHeight", 1.3f, 0.3f, 5f, "Root height above sampled terrain or water; at least bob amplitude plus 0.2m."));
			SurfaceInterval = Number(config, "Movement", "SurfaceCheckSeconds", 0.25f, 0.1f, 2f, "Interval for terrain, water and obstacle samples; filtered every frame. No scene scans.");
			ObstacleRadius = Number(config, "Movement", "ObstacleRadius", 0.15f, 0.05f, 0.5f, "Sphere-cast clearance against terrain and structures.");
			ObstacleDistance = Number(config, "Movement", "ObstacleLookAhead", 0.9f, 0.3f, 3f, "Minimum obstacle look-ahead distance; automatically increased for speed/check interval.");
			Diagnostics = config.Bind<bool>("Diagnostics", "LogOwnership", false, "Log owner changes per spirit; no per-frame logging.").Value;
		}

		private static float Number(ConfigFile config, string section, string key, float value, float min, float max, string description)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			return config.Bind<float>(section, key, value, new ConfigDescription(description, (AcceptableValueBase)(object)new AcceptableValueRange<float>(min, max), Array.Empty<object>())).Value;
		}
	}
	internal sealed class SpiritVisuals
	{
		private readonly SpiritSettings settings;

		private readonly ManualLogSource log;

		private Material glow;

		private Texture2D radial;

		internal int MaterialCount => Object.op_Implicit((Object)(object)glow) ? 1 : 0;

		internal SpiritVisuals(SpiritSettings settings, ManualLogSource log)
		{
			this.settings = settings;
			this.log = log;
		}

		internal void Build(GameObject donor, GameObject root)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected O, but got Unknown
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Expected O, but got Unknown
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			Transform val = donor.transform.Find("effects/flare");
			ParticleSystemRenderer val2 = (Object.op_Implicit((Object)(object)val) ? ((Component)val).GetComponent<ParticleSystemRenderer>() : null);
			Material val3 = (Object.op_Implicit((Object)(object)val2) ? ((Renderer)val2).sharedMaterial : null);
			if (!Object.op_Implicit((Object)(object)val3) || ((Object)val3.shader).name != "Legacy Shaders/Particles/Alpha Blended" || !val3.HasProperty("_TintColor") || !val3.HasProperty("_MainTex"))
			{
				throw new InvalidOperationException("Inspected LuredWisp transparent flare material is missing/changed; refusing a solid fallback.");
			}
			radial = CreateRadialTexture();
			glow = new Material(val3)
			{
				name = "PrimeForestSpirit_FireflyGlow",
				renderQueue = 3000
			};
			glow.SetTexture("_MainTex", (Texture)(object)radial);
			Color val4 = settings.FireflyColor * 0.5f;
			val4.a = settings.CoreOpacity * settings.PulseMinimum * 0.5f;
			glow.SetColor("_TintColor", val4);
			if (glow.HasProperty("_ZWrite"))
			{
				glow.SetInt("_ZWrite", 0);
			}
			if (glow.HasProperty("_SrcBlend"))
			{
				glow.SetInt("_SrcBlend", 5);
			}
			if (glow.HasProperty("_DstBlend"))
			{
				glow.SetInt("_DstBlend", 10);
			}
			GameObject val5 = new GameObject("PrimeForestSpiritVisuals");
			val5.transform.SetParent(root.transform, false);
			val5.transform.localScale = Vector3.one * settings.Scale;
			ParticleSystemRenderer val6 = CreatePoint(val5.transform, "PrimeFireflyCore", settings.CoreDiameter);
			ParticleSystemRenderer val7 = CreatePoint(val5.transform, "PrimeFireflyHalo", settings.HaloDiameter);
			GameObject val8 = new GameObject("PrimeFireflyLight");
			val8.transform.SetParent(val5.transform, false);
			Light obj = val8.AddComponent<Light>();
			obj.type = (LightType)2;
			obj.color = settings.FireflyColor;
			obj.intensity = settings.LightIntensity * settings.PulseMinimum;
			obj.range = settings.LightRange;
			obj.shadows = (LightShadows)0;
			LightLod obj2 = val8.AddComponent<LightLod>();
			obj2.m_lightLod = true;
			obj2.m_lightDistance = settings.LightDistance;
			obj2.m_shadowLod = false;
			LODGroup component = donor.GetComponent<LODGroup>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				throw new InvalidOperationException("LuredWisp LODGroup missing.");
			}
			LOD[] lODs = component.GetLODs();
			if (lODs.Length != 1)
			{
				throw new InvalidOperationException("Unexpected LuredWisp LOD layout; review before registration.");
			}
			lODs[0].renderers = (Renderer[])(object)new Renderer[2]
			{
				(Renderer)val6,
				(Renderer)val7
			};
			lODs[0].screenRelativeTransitionHeight = 0f;
			LODGroup obj3 = root.AddComponent<LODGroup>();
			obj3.SetLODs(lODs);
			obj3.fadeMode = component.fadeMode;
			obj3.animateCrossFading = component.animateCrossFading;
			obj3.localReferencePoint = component.localReferencePoint * settings.Scale;
			obj3.size = component.size * settings.Scale;
			obj3.enabled = component.enabled;
			log.LogInfo((object)("Firefly visuals: no solid mesh, sparks or trails; two stationary billboards, one owned material/radial texture. Shader=" + ((Object)glow.shader).name + "; core/halo=" + settings.CoreDiameter + "/" + settings.HaloDiameter + "m; screen-size cull removed, glow-only distance=" + settings.VisualDistance + "m; light range unchanged=" + settings.LightRange + "m."));
		}

		private Texture2D CreateRadialTexture()
		{
			//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_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: 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_00e7: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			Color[] array = (Color[])(object)new Color[16384];
			for (int i = 0; i < 128; i++)
			{
				for (int j = 0; j < 128; j++)
				{
					double num = 2.0 * (double)j / 127.0 - 1.0;
					double num2 = 2.0 * (double)i / 127.0 - 1.0;
					array[i * 128 + j] = new Color(1f, 1f, 1f, FireflyMath.RadialAlpha(Math.Sqrt(num * num + num2 * num2)));
				}
			}
			Texture2D val = new Texture2D(128, 128, (TextureFormat)4, true)
			{
				name = "PrimeForestSpirit_RadialGlow",
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1
			};
			val.SetPixels(array);
			val.Apply(true, true);
			return val;
		}

		private ParticleSystemRenderer CreatePoint(Transform parent, string name, float diameter)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0024: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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_0084: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: 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_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: 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_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			ParticleSystem val2 = val.AddComponent<ParticleSystem>();
			val2.Stop(true, (ParticleSystemStopBehavior)0);
			MainModule main = val2.main;
			((MainModule)(ref main)).duration = 1f;
			((MainModule)(ref main)).loop = true;
			((MainModule)(ref main)).playOnAwake = true;
			((MainModule)(ref main)).startLifetime = MinMaxCurve.op_Implicit(float.PositiveInfinity);
			((MainModule)(ref main)).startSpeed = MinMaxCurve.op_Implicit(0f);
			((MainModule)(ref main)).startSize3D = false;
			((MainModule)(ref main)).startSize = MinMaxCurve.op_Implicit(diameter);
			((MainModule)(ref main)).startColor = MinMaxGradient.op_Implicit(Color.white);
			((MainModule)(ref main)).maxParticles = 1;
			((MainModule)(ref main)).simulationSpace = (ParticleSystemSimulationSpace)0;
			((MainModule)(ref main)).scalingMode = (ParticleSystemScalingMode)0;
			ShapeModule shape = val2.shape;
			((ShapeModule)(ref shape)).enabled = false;
			EmissionModule emission = val2.emission;
			((EmissionModule)(ref emission)).enabled = true;
			((EmissionModule)(ref emission)).rateOverTime = MinMaxCurve.op_Implicit(0f);
			((EmissionModule)(ref emission)).rateOverDistance = MinMaxCurve.op_Implicit(0f);
			((EmissionModule)(ref emission)).SetBursts((Burst[])(object)new Burst[1]
			{
				new Burst(0f, (short)1)
			});
			TrailModule trails = val2.trails;
			((TrailModule)(ref trails)).enabled = false;
			LightsModule lights = val2.lights;
			((LightsModule)(ref lights)).enabled = false;
			CollisionModule collision = val2.collision;
			((CollisionModule)(ref collision)).enabled = false;
			TriggerModule trigger = val2.trigger;
			((TriggerModule)(ref trigger)).enabled = false;
			ExternalForcesModule externalForces = val2.externalForces;
			((ExternalForcesModule)(ref externalForces)).enabled = false;
			ParticleSystemRenderer val3 = val.GetComponent<ParticleSystemRenderer>();
			if (!Object.op_Implicit((Object)(object)val3))
			{
				val3 = val.AddComponent<ParticleSystemRenderer>();
			}
			val3.renderMode = (ParticleSystemRenderMode)0;
			val3.alignment = (ParticleSystemRenderSpace)0;
			((Renderer)val3).sharedMaterial = glow;
			((Renderer)val3).shadowCastingMode = (ShadowCastingMode)0;
			((Renderer)val3).receiveShadows = false;
			return val3;
		}

		internal static void Validate(GameObject root)
		{
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			Component[] componentsInChildren = root.GetComponentsInChildren<Component>(true);
			foreach (Component val in componentsInChildren)
			{
				if (!Object.op_Implicit((Object)(object)val))
				{
					throw new InvalidOperationException("Unresolved script in firefly prefab.");
				}
				bool num;
				if (!((Object)(object)val.gameObject == (Object)(object)root))
				{
					if (val is Transform || val is ParticleSystem || val is ParticleSystemRenderer || val is Light)
					{
						continue;
					}
					num = val is LightLod;
				}
				else
				{
					if (val is Transform || val is ZNetView || val is ZSyncTransform || val is SpiritWander || val is FireflyPulse || val is FireflyVisibility || val is SpiritLifetime)
					{
						continue;
					}
					num = val is LODGroup;
				}
				if (!num)
				{
					throw new InvalidOperationException("Disallowed firefly component: " + ((object)val).GetType().FullName);
				}
			}
			if (root.GetComponentsInChildren<ParticleSystem>(true).Length != 2 || root.GetComponentsInChildren<ParticleSystemRenderer>(true).Length != 2 || root.GetComponentsInChildren<Light>(true).Length != 1)
			{
				throw new InvalidOperationException("Expected exactly two glow systems and one point light.");
			}
			LODGroup component = root.GetComponent<LODGroup>();
			LOD[] array = (LOD[])(Object.op_Implicit((Object)(object)component) ? ((Array)component.GetLODs()) : ((Array)new LOD[0]));
			if (array.Length != 1 || array[0].renderers.Length != 2 || (Object)(object)array[0].renderers[0] == (Object)(object)array[0].renderers[1])
			{
				throw new InvalidOperationException("Expected exactly two distinct firefly LOD renderers.");
			}
			if (array[0].screenRelativeTransitionHeight != 0f)
			{
				throw new InvalidOperationException("Unexpected screen-size cutoff on extended-visibility firefly.");
			}
			Renderer[] renderers = array[0].renderers;
			foreach (Renderer val2 in renderers)
			{
				if (!(val2 is ParticleSystemRenderer) || !((Component)val2).transform.IsChildOf(root.transform))
				{
					throw new InvalidOperationException("Firefly LOD refers outside its billboard hierarchy.");
				}
			}
			ParticleSystem[] componentsInChildren2 = root.GetComponentsInChildren<ParticleSystem>(true);
			int i = 0;
			while (i < componentsInChildren2.Length)
			{
				ParticleSystem val3 = componentsInChildren2[i];
				MainModule main = val3.main;
				if (((MainModule)(ref main)).maxParticles == 1)
				{
					main = val3.main;
					if ((int)((MainModule)(ref main)).simulationSpace == 0)
					{
						TrailModule trails = val3.trails;
						if (!((TrailModule)(ref trails)).enabled)
						{
							CollisionModule collision = val3.collision;
							if (!((CollisionModule)(ref collision)).enabled)
							{
								TriggerModule trigger = val3.trigger;
								if (!((TriggerModule)(ref trigger)).enabled)
								{
									LightsModule lights = val3.lights;
									if (!((LightsModule)(ref lights)).enabled)
									{
										i++;
										continue;
									}
								}
							}
						}
					}
				}
				throw new InvalidOperationException("Unexpected gameplay, trail or particle count in glow system.");
			}
		}
	}
	[DefaultExecutionOrder(200)]
	public sealed class FireflyPulse : MonoBehaviour
	{
		private ZNetView view;

		private ParticleSystemRenderer core;

		private ParticleSystemRenderer halo;

		private Light pointLight;

		private MaterialPropertyBlock properties;

		private SpiritSettings settings;

		private double period;

		private double cycle;

		private bool initialized;

		private FireflyVisibility visibility;

		private static readonly int TintId = Shader.PropertyToID("_TintColor");

		private void Start()
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Expected O, but got Unknown
			view = ((Component)this).GetComponent<ZNetView>();
			settings = PrimeForestSpiritPlugin.Settings;
			visibility = ((Component)this).GetComponent<FireflyVisibility>();
			Transform val = ((Component)this).transform.Find("PrimeForestSpiritVisuals");
			if (!Object.op_Implicit((Object)(object)view) || !Object.op_Implicit((Object)(object)val) || settings == null)
			{
				((Behaviour)this).enabled = false;
				return;
			}
			core = ((Component)val.Find("PrimeFireflyCore")).GetComponent<ParticleSystemRenderer>();
			halo = ((Component)val.Find("PrimeFireflyHalo")).GetComponent<ParticleSystemRenderer>();
			pointLight = ((Component)val.Find("PrimeFireflyLight")).GetComponent<Light>();
			properties = new MaterialPropertyBlock();
			Apply(settings.PulseMinimum);
		}

		private void LateUpdate()
		{
			if (settings != null && properties != null && Object.op_Implicit((Object)(object)view) && view.IsValid() && (!Object.op_Implicit((Object)(object)visibility) || visibility.Visible))
			{
				if (!initialized)
				{
					FireflyMath.Parameters((uint)((object)Unsafe.As<ZDOID, ZDOID>(ref view.GetZDO().m_uid)/*cast due to .constrained prefix*/).GetHashCode(), settings.PulseMinSeconds, settings.PulseMaxSeconds, out period, out cycle);
					initialized = true;
				}
				cycle = (cycle + (double)Mathf.Min(Time.deltaTime, 0.1f) / period) % 1.0;
				Apply(FireflyMath.Pulse(cycle, settings.PulseMinimum));
			}
		}

		private void Apply(float pulse)
		{
			SetTint((Renderer)(object)core, settings.CoreBrightness, settings.CoreOpacity * pulse);
			SetTint((Renderer)(object)halo, settings.HaloBrightness, settings.HaloOpacity * pulse);
			pointLight.intensity = settings.LightIntensity * pulse;
		}

		private void SetTint(Renderer renderer, float brightness, float alpha)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: 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)
			Color val = settings.FireflyColor * (brightness * 0.5f);
			val.a = alpha * 0.5f;
			properties.SetColor(TintId, val);
			renderer.SetPropertyBlock(properties);
		}
	}
	internal static class FireflyMath
	{
		internal static float RadialAlpha(double radius)
		{
			double num = Math.Max(0.0, 1.0 - radius * radius);
			if (!(radius >= 1.0))
			{
				return (float)(num * num * num);
			}
			return 0f;
		}

		internal static float Pulse(double cycle, float minimum)
		{
			return minimum + (1f - minimum) * (float)(0.5 - 0.5 * Math.Cos(Math.PI * 2.0 * cycle));
		}

		internal static void Parameters(uint identity, float min, float max, out double period, out double cycle)
		{
			uint num = identity ^ 0xF17EF17Eu;
			num ^= num >> 16;
			num *= 2146121005;
			num ^= num >> 15;
			num *= 2221713035u;
			num ^= num >> 16;
			period = (double)min + (double)(max - min) * SpiritMath.Next01(ref num);
			cycle = SpiritMath.Next01(ref num);
		}
	}
	public sealed class FireflyVisibility : MonoBehaviour
	{
		private Renderer core;

		private Renderer halo;

		private SpiritSettings settings;

		private float timer;

		private bool visible = true;

		private GameObject visualRoot;

		private static int conditionFrame = -1;

		private static bool night;

		private static bool restored;

		internal bool Visible => visible;

		private void Start()
		{
			settings = PrimeForestSpiritPlugin.Settings;
			Transform val = ((Component)this).transform.Find("PrimeForestSpiritVisuals");
			if (!Object.op_Implicit((Object)(object)val) || settings == null)
			{
				((Behaviour)this).enabled = false;
				return;
			}
			visualRoot = ((Component)val).gameObject;
			core = (Renderer)(object)((Component)val.Find("PrimeFireflyCore")).GetComponent<ParticleSystemRenderer>();
			halo = (Renderer)(object)((Component)val.Find("PrimeFireflyHalo")).GetComponent<ParticleSystemRenderer>();
		}

		private void Update()
		{
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			if (settings == null || !Object.op_Implicit((Object)(object)core) || !Object.op_Implicit((Object)(object)halo))
			{
				return;
			}
			timer -= Time.deltaTime;
			if (!(timer > 0f))
			{
				timer = settings.VisibilityInterval;
				if (conditionFrame != Time.frameCount)
				{
					conditionFrame = Time.frameCount;
					night = Object.op_Implicit((Object)(object)EnvMan.instance) && EnvMan.IsNight();
					restored = PrimeForestSpiritPlugin.RestorationGate?.Invoke() ?? (Object.op_Implicit((Object)(object)ZoneSystem.instance) && ZoneSystem.instance.GetGlobalKey("prime_swamp_restored"));
				}
				Camera mainCamera = Utils.GetMainCamera();
				bool num = night;
				bool num2 = restored;
				bool camera = Object.op_Implicit((Object)(object)mainCamera);
				float squaredDistance;
				if (!Object.op_Implicit((Object)(object)mainCamera))
				{
					squaredDistance = float.MaxValue;
				}
				else
				{
					Vector3 val = ((Component)mainCamera).transform.position - ((Component)this).transform.position;
					squaredDistance = ((Vector3)(ref val)).sqrMagnitude;
				}
				bool flag = FireflyActivityPolicy.Visible(num, num2, camera, squaredDistance, settings.VisualDistance, settings.VisibilityHysteresis, visible);
				if (flag != visible)
				{
					visible = flag;
					core.forceRenderingOff = !visible;
					halo.forceRenderingOff = !visible;
					visualRoot.SetActive(visible);
				}
			}
		}
	}
	internal static class FireflyActivityPolicy
	{
		internal static bool Visible(bool night, bool restored, bool camera, float squaredDistance, float distance, float hysteresis, bool wasVisible)
		{
			float num = distance + (wasVisible ? hysteresis : 0f);
			if (night && restored && camera)
			{
				return squaredDistance <= num * num;
			}
			return false;
		}
	}
	public sealed class SpiritWander : MonoBehaviour
	{
		private const string HomeKey = "PrimeForestSpirit_home";

		private const string InitializedKey = "PrimeForestSpirit_initialized";

		private const string RandomKey = "PrimeForestSpirit_random";

		private const string PauseKey = "PrimeForestSpirit_paused";

		private const string DeadlineKey = "PrimeForestSpirit_deadline";

		private ZNetView view;

		private Transform visual;

		private SpiritSettings settings;

		private Vector3 home;

		private Vector3 velocity;

		private Vector3 avoidance;

		private Vector3 sampledAvoidance;

		private Vector3 renderPosition;

		private WaterVolume water;

		private uint random;

		private double phase;

		private float surfaceTimer;

		private float floorHeight;

		private float filteredFloor;

		private long deadline;

		private bool wasOwner;

		private bool initialized;

		private bool paused;

		private bool surfaceReady;

		private bool haveFloor;

		private int obstacleMask;

		private void Start()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			view = ((Component)this).GetComponent<ZNetView>();
			visual = ((Component)this).transform.Find("PrimeForestSpiritVisuals");
			settings = PrimeForestSpiritPlugin.Settings;
			renderPosition = ((Component)this).transform.position;
			obstacleMask = LayerMask.GetMask(new string[5] { "Default", "static_solid", "Default_small", "piece", "terrain" });
			if (!Object.op_Implicit((Object)(object)view) || !Object.op_Implicit((Object)(object)visual) || settings == null)
			{
				((Behaviour)this).enabled = false;
			}
		}

		private void Update()
		{
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: 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_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_033e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0351: Unknown result type (might be due to invalid IL or missing references)
			//IL_0356: Unknown result type (might be due to invalid IL or missing references)
			//IL_0361: Unknown result type (might be due to invalid IL or missing references)
			//IL_0366: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_0376: Unknown result type (might be due to invalid IL or missing references)
			//IL_038a: Unknown result type (might be due to invalid IL or missing references)
			//IL_039e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03df: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)view) || !view.IsValid() || settings == null || !Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return;
			}
			ZDO zDO = view.GetZDO();
			phase = (double)((uint)((object)Unsafe.As<ZDOID, ZDOID>(ref zDO.m_uid)/*cast due to .constrained prefix*/).GetHashCode() % 65521u) * 9.589574803772205E-05;
			bool flag = view.IsOwner();
			if (flag && !wasOwner)
			{
				ReadOwnerState(zDO);
			}
			if (flag != wasOwner && Object.op_Implicit((Object)(object)PrimeForestSpiritPlugin.Instance))
			{
				PrimeForestSpiritPlugin.Instance.Diagnostic(((Object)this).name + " network owner=" + flag);
			}
			wasOwner = flag;
			if (!flag || !initialized)
			{
				return;
			}
			float num = Mathf.Min(Time.deltaTime, 0.1f);
			long ticks = ZNet.instance.GetTime().Ticks;
			surfaceTimer -= num;
			if (surfaceTimer <= 0f)
			{
				SampleSurfaceAndObstacle();
				surfaceTimer = settings.SurfaceInterval;
			}
			if (!surfaceReady)
			{
				velocity = Vector3.zero;
				return;
			}
			if (ticks >= deadline)
			{
				ChooseNext(zDO, ticks);
			}
			filteredFloor = Mathf.Lerp(filteredFloor, floorHeight, SpiritMath.Ease(settings.SurfaceResponse, num));
			avoidance = Vector3.Lerp(avoidance, sampledAvoidance, SpiritMath.Ease(settings.AvoidanceResponse, num));
			Vector3 val = Vector3.zero;
			if (!paused)
			{
				SpiritMath.Curve(ZNet.instance.GetTimeSeconds(), phase, settings.Radius, settings.CurveRate, out var x, out var z);
				Vector3 val2 = home + new Vector3((float)x, 0f, (float)z) - ((Component)this).transform.position;
				val2.y = 0f;
				val = Vector3.ClampMagnitude(val2 / 1.5f + avoidance * settings.Speed, settings.Speed);
				Vector3 val3 = ((Component)this).transform.position - home;
				val3.y = 0f;
				float magnitude = ((Vector3)(ref val3)).magnitude;
				if (magnitude > settings.Radius * 0.8f)
				{
					float num2 = Mathf.Clamp01((magnitude / settings.Radius - 0.8f) / 0.2f);
					val = Vector3.Lerp(val, -((Vector3)(ref val3)).normalized * settings.Speed, num2);
				}
			}
			float num3 = filteredFloor + settings.HoverHeight - ((Component)this).transform.position.y;
			val.y = Mathf.Clamp(num3 * settings.SurfaceResponse, (0f - settings.Speed) * 0.7f, settings.Speed * 0.7f);
			velocity = Vector3.Lerp(velocity, val, SpiritMath.Ease(settings.Steering, num));
			Vector3 position = ((Component)this).transform.position;
			Vector3 val4 = velocity * num;
			float num4 = (float)SpiritMath.DiscStepFraction(position.x - home.x, position.z - home.z, val4.x, val4.z, settings.Radius);
			Vector3 position2 = position + val4 * num4;
			if (num4 < 1f)
			{
				velocity *= num4;
			}
			position2.y = position.y + val4.y;
			((Component)this).transform.position = position2;
		}

		private void LateUpdate()
		{
			//IL_003e: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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)
			if (Object.op_Implicit((Object)(object)visual) && settings != null && Object.op_Implicit((Object)(object)view) && view.IsValid() && Object.op_Implicit((Object)(object)ZNet.instance))
			{
				renderPosition = Vector3.Lerp(renderPosition, ((Component)this).transform.position, SpiritMath.Ease(settings.RenderResponse, Mathf.Min(Time.deltaTime, 0.1f)));
				visual.position = renderPosition + Vector3.up * SpiritMath.Bob(ZNet.instance.GetTimeSeconds(), settings.BobAmplitude, settings.BobPeriod, phase);
			}
		}

		private void ReadOwnerState(ZDO zdo)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			initialized = zdo.GetBool("PrimeForestSpirit_initialized", false);
			if (!initialized)
			{
				home = ((Component)this).transform.position;
				random = (uint)((object)Unsafe.As<ZDOID, ZDOID>(ref zdo.m_uid)/*cast due to .constrained prefix*/).GetHashCode();
				if (random == 0)
				{
					random = 2654435769u;
				}
				paused = true;
				deadline = 0L;
				zdo.Set("PrimeForestSpirit_home", home);
				WriteLeg(zdo);
				zdo.Set("PrimeForestSpirit_initialized", true);
				initialized = true;
			}
			else
			{
				home = zdo.GetVec3("PrimeForestSpirit_home", ((Component)this).transform.position);
				random = (uint)zdo.GetInt("PrimeForestSpirit_random", 1);
				paused = zdo.GetBool("PrimeForestSpirit_paused", false);
				deadline = zdo.GetLong("PrimeForestSpirit_deadline", 0L);
			}
			velocity = Vector3.zero;
			surfaceTimer = 0f;
			haveFloor = false;
		}

		private void ChooseNext(ZDO zdo, long now)
		{
			bool flag = !paused && SpiritMath.Next01(ref random) < (double)settings.PauseChance;
			paused = flag;
			float num = ((!paused) ? Range(settings.LegMin, settings.LegMax) : Range(settings.PauseMin, settings.PauseMax));
			deadline = now + (long)(num * 10000000f);
			WriteLeg(zdo);
		}

		private float Range(float min, float max)
		{
			return min + (max - min) * (float)SpiritMath.Next01(ref random);
		}

		private void WriteLeg(ZDO zdo)
		{
			zdo.Set("PrimeForestSpirit_random", (int)random);
			zdo.Set("PrimeForestSpirit_paused", paused);
			zdo.Set("PrimeForestSpirit_deadline", deadline);
		}

		private void SampleSurfaceAndObstacle()
		{
			//IL_0018: 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_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: 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)
			surfaceReady = Object.op_Implicit((Object)(object)ZoneSystem.instance) && ZoneSystem.instance.GetGroundHeight(((Component)this).transform.position, ref floorHeight);
			if (surfaceReady)
			{
				float waterLevel = Floating.GetWaterLevel(((Component)this).transform.position, ref water);
				floorHeight = Mathf.Max(floorHeight, waterLevel);
				floorHeight = Mathf.Max(floorHeight, ZoneSystem.instance.m_waterLevel);
				if (!haveFloor)
				{
					filteredFloor = floorHeight;
					haveFloor = true;
				}
				Vector3 val = velocity;
				val.y = 0f;
				float num = Mathf.Max(settings.ObstacleDistance, settings.Speed * settings.SurfaceInterval * 2f + settings.ObstacleRadius);
				sampledAvoidance = Vector3.zero;
				RaycastHit val2 = default(RaycastHit);
				if (((Vector3)(ref val)).sqrMagnitude > 0.01f && Physics.SphereCast(((Component)this).transform.position, settings.ObstacleRadius, ((Vector3)(ref val)).normalized, ref val2, num, obstacleMask, (QueryTriggerInteraction)1))
				{
					Vector3 normal = ((RaycastHit)(ref val2)).normal;
					normal.y = 0f;
					sampledAvoidance = ((Vector3)(ref normal)).normalized * 2f;
				}
			}
		}
	}
	internal static class SpiritMath
	{
		internal static double Next01(ref uint state)
		{
			if (state == 0)
			{
				state = 2654435769u;
			}
			state ^= state << 13;
			state ^= state >> 17;
			state ^= state << 5;
			return (double)(state >> 8) / 16777216.0;
		}

		internal static void Disc(ref uint state, double radius, out double x, out double z)
		{
			double num = Next01(ref state) * Math.PI * 2.0;
			double num2 = Math.Sqrt(Next01(ref state)) * radius;
			x = Math.Cos(num) * num2;
			z = Math.Sin(num) * num2;
		}

		internal static float Ease(float rate, float dt)
		{
			return (float)(1.0 - Math.Exp((0f - Math.Max(0f, rate)) * Math.Max(0f, dt)));
		}

		internal static void Curve(double time, double phase, double radius, double rate, out double x, out double z)
		{
			double num = time * rate + phase + 0.16 * Math.Sin(time * rate * 0.43 + phase * 0.7);
			double num2 = (0.0 - time) * rate * 1.371 + phase * 1.731;
			x = radius * (0.55 * Math.Cos(num) + 0.2 * Math.Cos(num2));
			z = radius * (0.55 * Math.Sin(num) + 0.2 * Math.Sin(num2));
		}

		internal static double DiscStepFraction(double x, double z, double dx, double dz, double radius)
		{
			double num = x * x + z * z;
			double num2 = (x + dx) * (x + dx) + (z + dz) * (z + dz);
			double num3 = radius * radius;
			if (num > num3 + 1E-09)
			{
				return (num2 <= num) ? 1 : 0;
			}
			if (num2 <= num3)
			{
				return 1.0;
			}
			double num4 = dx * dx + dz * dz;
			if (num4 < 1E-16)
			{
				return 0.0;
			}
			double num5 = 2.0 * (x * dx + z * dz);
			double num6 = num - num3;
			return Math.Max(0.0, Math.Min(1.0, (0.0 - num5 + Math.Sqrt(Math.Max(0.0, num5 * num5 - 4.0 * num4 * num6))) / (2.0 * num4)));
		}

		internal static float Bob(double time, float amplitude, float period, double phase)
		{
			return amplitude * (float)((Math.Sin(time * Math.PI * 2.0 / (double)period + phase) + 0.23 * Math.Sin(time * Math.PI * 2.0 / ((double)period * 1.731) + phase * 1.37)) / 1.23);
		}
	}
	public sealed class SpiritLifetime : MonoBehaviour
	{
		private const string ExpiryKey = "PrimeForestSpirit_ambientExpiry";

		private ZNetView view;

		private float checkTimer;

		private bool destroying;

		private void Start()
		{
			view = ((Component)this).GetComponent<ZNetView>();
		}

		private void Update()
		{
			checkTimer -= Time.deltaTime;
			if (checkTimer > 0f || destroying)
			{
				return;
			}
			checkTimer = 1f;
			if (Object.op_Implicit((Object)(object)view) && view.IsValid() && view.IsOwner() && Object.op_Implicit((Object)(object)ZNet.instance) && Object.op_Implicit((Object)(object)ZNetScene.instance))
			{
				ZDO zDO = view.GetZDO();
				long ticks = ZNet.instance.GetTime().Ticks;
				long num = zDO.GetLong("PrimeForestSpirit_ambientExpiry", 0L);
				if (num == 0L)
				{
					num = ticks + SpiritLifetimeMath.DurationTicks((uint)((object)Unsafe.As<ZDOID, ZDOID>(ref zDO.m_uid)/*cast due to .constrained prefix*/).GetHashCode());
					zDO.Set("PrimeForestSpirit_ambientExpiry", num);
				}
				if (ticks >= num)
				{
					destroying = true;
					ZNetScene.instance.Destroy(((Component)this).gameObject);
				}
			}
		}
	}
	internal static class SpiritLifetimeMath
	{
		internal static long DurationTicks(uint identity)
		{
			FireflyMath.Parameters(identity ^ 0xA6B13C59u, 240f, 360f, out var period, out var _);
			return (long)(period * 10000000.0);
		}
	}
}