using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;

[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("NightSky")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Test")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("NightSky")]
[assembly: AssemblyTitle("NightSky")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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;
		}
	}
}
[BepInPlugin("NightSkyPlugin", "Night Sky Plugin", "1.0.0")]
public class NightSkyPlugin : BaseUnityPlugin
{
	private NightSkyController nightSkyController;

	private void Awake()
	{
		Debug.Log((object)"Nightsky loaded");
	}
}
public class NightSkyController : MonoBehaviour
{
	[Header("On Planet Settings")]
	public float starBrightness = 6f;

	[Header("In Space Settings")]
	public bool movePlanetOnly;

	public bool inSpace;

	public Vector3 sunRotateVector = new Vector3(0.002f, 0f, 0f);

	public Vector3 moonRotateVector = new Vector3(0.002f, 0f, 0f);

	public Vector3 planetRotateVector = new Vector3(0f, 0f, -0.002f);

	[Space]
	public float orbitHeight = 80000f;

	public float planetRadius = 6378100f;

	public Cubemap planetTexture;

	[Header("References")]
	public GameObject sun;

	public GameObject moon;

	[Space]
	public Volume stormySkyVolume;

	public Volume eclipsedSkyVolume;

	public Volume clearSkyVolume;

	private PhysicallyBasedSky sky;

	public void Awake()
	{
		SetSettings();
	}

	private void OnValidate()
	{
		SetSettings();
	}

	private void FixedUpdate()
	{
		if (inSpace)
		{
			SpaceSimulation();
		}
		else if (!inSpace)
		{
			((VolumeParameter<float>)(object)sky.spaceEmissionMultiplier).value = starBrightness;
		}
	}

	public void Update()
	{
	}

	public void SetSettings()
	{
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)clearSkyVolume != (Object)null)
		{
			clearSkyVolume.profile.TryGet<PhysicallyBasedSky>(ref sky);
		}
		else if ((Object)(object)stormySkyVolume != (Object)null)
		{
			stormySkyVolume.profile.TryGet<PhysicallyBasedSky>(ref sky);
		}
		else if ((Object)(object)stormySkyVolume != (Object)null)
		{
			eclipsedSkyVolume.profile.TryGet<PhysicallyBasedSky>(ref sky);
		}
		else
		{
			Debug.LogError((object)"[Night Sky] No Volumes where found");
		}
		if (inSpace)
		{
			((VolumeParameter<Texture>)(object)sky.groundColorTexture).value = (Texture)(object)planetTexture;
			((VolumeParameter<Texture>)(object)sky.groundEmissionTexture).value = (Texture)(object)planetTexture;
			((VolumeParameter<float>)(object)sky.planetaryRadius).value = planetRadius;
			((VolumeParameter<Vector3>)(object)sky.planetCenterPosition).value = new Vector3(0f, 0f - (((VolumeParameter<float>)(object)sky.planetaryRadius).value + orbitHeight), 0f);
		}
	}

	private void SpaceSimulation()
	{
		//IL_000c: 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_0059: 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_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: 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)
		Vector3Parameter planetRotation = sky.planetRotation;
		((VolumeParameter<Vector3>)(object)planetRotation).value = ((VolumeParameter<Vector3>)(object)planetRotation).value + planetRotateVector;
		if (!movePlanetOnly)
		{
			if ((Object)(object)moon != (Object)null)
			{
				moon.transform.Rotate(moonRotateVector);
			}
			sun.transform.Rotate(sunRotateVector);
			Vector3Parameter spaceRotation = sky.spaceRotation;
			((VolumeParameter<Vector3>)(object)spaceRotation).value = ((VolumeParameter<Vector3>)(object)spaceRotation).value + planetRotateVector;
		}
	}
}

using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;

[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("WanderingCreature")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Test")]
[assembly: AssemblyFileVersion("1.2.1.0")]
[assembly: AssemblyInformationalVersion("1.2.1")]
[assembly: AssemblyProduct("WanderingCreature")]
[assembly: AssemblyTitle("WanderingCreature")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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;
		}
	}
}
[BepInPlugin("WanderingCreature", "Wandering Creature", "1.2.1")]
public class WanderingCreature : BaseUnityPlugin
{
	private void Awake()
	{
		Debug.Log((object)"WanderingCreaturePlugin loaded");
	}
}
public class WanderingCreatureController : NetworkBehaviour
{
	[Header("Movement")]
	[Tooltip("The maximum distance from the creature's current position within which it can wander.")]
	public float wanderRadius = 10f;

	[Tooltip("The duration the creature waits at its destination before selecting a new destination to wander towards.")]
	public float waitTime = 3f;

	[Tooltip("If enabled, the wait time becomes random within the range [0, Wait Time].")]
	public bool randomTime;

	[Tooltip("Toggle whether the creature is allowed to wander or not.")]
	public bool wanderEnabled = true;

	[Tooltip("When enabled, the creature will only wander around its spawn point within a radius defined by the Wander Radius. If disabled, the creature can wander from any point within the Wander Radius.")]
	public bool anchoredWandering = true;

	[Header("Audio")]
	public AudioSource ambientAudioSource;

	[Tooltip("An array of audio clips that can be played randomly at intervals while the creature is wandering.")]
	public AudioClip[] ambientAudioClips;

	[Tooltip("The minimum interval between playing ambient audio clips.")]
	public float minAmbientAudioInterval = 3f;

	[Tooltip("The maximum interval between playing ambient audio clips.")]
	public float maxAmbientAudioInterval = 7f;

	[Tooltip("The volume for ambient audio.")]
	[Range(0f, 2f)]
	public float ambientAudioVolume = 1f;

	[Space]
	public AudioSource walkingAudioSource;

	[Tooltip("An array of audio clips that can be played randomly at intervals while the creature is moving.")]
	public AudioClip[] walkingAudioClips;

	[Tooltip("The interval between playing walking audio clips.")]
	public float walkingAudioInterval = 0.5f;

	[Tooltip("The volume for walking audio.")]
	[Range(0f, 2f)]
	public float walkingAudioVolume = 1f;

	[Header("Rotation")]
	[Tooltip("If enabled, the creature will follow the surface normal underneath it.")]
	public bool followSurface;

	[Tooltip("The distance to cast the ray to detect the surface normal.")]
	public float surfaceNormalRaycastDistance = 2f;

	private NavMeshAgent agent;

	private bool isMoving;

	private bool startMovingSignal;

	private float waitTimer;

	private float ambientAudioTimer;

	private float walkingAudioTimer;

	private int currentAmbientClipIndex;

	private Vector3 startPosition;

	private float lastSyncedAmbientAudioTimer;

	private float syncedWaitTimer;

	private void Start()
	{
		//IL_0007: 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)
		startPosition = ((Component)this).transform.position;
		agent = ((Component)this).GetComponent<NavMeshAgent>();
		if (((NetworkBehaviour)this).IsServer)
		{
			GenerateDestination();
			startMovingSignal = true;
		}
		if ((Object)(object)ambientAudioSource == (Object)null || (Object)(object)walkingAudioSource == (Object)null)
		{
			Debug.LogError((object)"WaderingCreatureController: One or both AudioSource components are not assigned!");
			return;
		}
		ambientAudioSource.volume = ambientAudioVolume;
		walkingAudioSource.volume = walkingAudioVolume;
	}

	private void Update()
	{
		//IL_007c: 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)
		if (!wanderEnabled)
		{
			return;
		}
		if (startMovingSignal && !isMoving && waitTimer <= 0f)
		{
			GenerateDestinationServerRpc();
			startMovingSignal = false;
		}
		if (isMoving)
		{
			if (!agent.pathPending && agent.remainingDistance <= agent.stoppingDistance)
			{
				if (agent.hasPath)
				{
					Vector3 velocity = agent.velocity;
					if (((Vector3)(ref velocity)).sqrMagnitude != 0f)
					{
						goto IL_010c;
					}
				}
				isMoving = false;
				syncedWaitTimer = waitTimer;
				WaitTimerSyncServerRpc(waitTimer);
				if (randomTime)
				{
					waitTimer = Random.Range(0f, waitTime);
				}
				else
				{
					waitTimer = waitTime;
				}
			}
		}
		else if (waitTimer > 0f)
		{
			waitTimer -= Time.deltaTime;
		}
		else if (((NetworkBehaviour)this).IsServer)
		{
			GenerateDestinationServerRpc();
		}
		goto IL_010c;
		IL_010c:
		if (ambientAudioClips != null && ambientAudioClips.Length != 0)
		{
			if (((NetworkBehaviour)this).IsServer)
			{
				ambientAudioTimer -= Time.deltaTime;
				if (ambientAudioTimer <= 0f)
				{
					ambientAudioTimer = Random.Range(minAmbientAudioInterval, maxAmbientAudioInterval);
					lastSyncedAmbientAudioTimer = ambientAudioTimer;
					AmbientAudioTimerSyncServerRpc(ambientAudioTimer);
				}
			}
			else
			{
				ambientAudioTimer = lastSyncedAmbientAudioTimer;
			}
			if (ambientAudioTimer <= 0f)
			{
				SelectAmbientAudioClipServerRpc();
			}
		}
		if (isMoving && walkingAudioClips != null)
		{
			walkingAudioTimer -= Time.deltaTime;
			if (walkingAudioTimer <= 0f)
			{
				int num = Random.Range(0, walkingAudioClips.Length);
				walkingAudioSource.clip = walkingAudioClips[num];
				walkingAudioSource.Play();
				walkingAudioTimer = walkingAudioInterval;
			}
		}
		if (followSurface)
		{
			RotateToFollowSurfaceNormal();
		}
	}

	private void GenerateDestination()
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: 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_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: 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_0019: 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_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = Random.insideUnitSphere * wanderRadius;
		if (anchoredWandering)
		{
			val += startPosition;
		}
		NavMeshHit val2 = default(NavMeshHit);
		NavMesh.SamplePosition(val, ref val2, wanderRadius, -1);
		Vector3 position = ((NavMeshHit)(ref val2)).position;
		agent.SetDestination(position);
		isMoving = true;
	}

	private void RotateToFollowSurfaceNormal()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: 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_002d: 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_0033: 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)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0048: 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)
		RaycastHit val = default(RaycastHit);
		if (Physics.Raycast(((Component)this).transform.position, Vector3.down, ref val, surfaceNormalRaycastDistance))
		{
			Vector3 normal = ((RaycastHit)(ref val)).normal;
			Quaternion rotation = Quaternion.FromToRotation(((Component)this).transform.up, normal) * ((Component)this).transform.rotation;
			((Component)this).transform.rotation = rotation;
		}
	}

	private void OnDrawGizmosSelected()
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		Gizmos.color = Color.green;
		Gizmos.DrawWireSphere(((Component)this).transform.position, wanderRadius);
	}

	[ServerRpc(RequireOwnership = false)]
	private void GenerateDestinationServerRpc()
	{
		GenerateDestination();
		GenerateDestinationClientRpc();
	}

	[ClientRpc]
	private void GenerateDestinationClientRpc()
	{
		isMoving = true;
	}

	[ServerRpc(RequireOwnership = false)]
	private void SelectAmbientAudioClipServerRpc()
	{
		currentAmbientClipIndex = Random.Range(0, ambientAudioClips.Length);
		SelectAmbientAudioClipClientRpc(currentAmbientClipIndex);
	}

	[ClientRpc]
	private void SelectAmbientAudioClipClientRpc(int clipIndex)
	{
		if (ambientAudioClips != null && ambientAudioClips.Length != 0)
		{
			currentAmbientClipIndex = clipIndex;
			ambientAudioSource.clip = ambientAudioClips[currentAmbientClipIndex];
			ambientAudioSource.Play();
		}
	}

	[ServerRpc(RequireOwnership = false)]
	private void AmbientAudioTimerSyncServerRpc(float timerValue)
	{
		lastSyncedAmbientAudioTimer = timerValue;
		AmbientAudioTimerSyncClientRpc(timerValue);
	}

	[ClientRpc]
	private void AmbientAudioTimerSyncClientRpc(float timerValue)
	{
		lastSyncedAmbientAudioTimer = timerValue;
	}

	[ServerRpc(RequireOwnership = false)]
	private void WaitTimerSyncServerRpc(float timerValue)
	{
		syncedWaitTimer = timerValue;
		WaitTimerSyncClientRpc(timerValue);
	}

	[ClientRpc]
	private void WaitTimerSyncClientRpc(float timerValue)
	{
		syncedWaitTimer = timerValue;
	}
}