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 BepInEx.Logging;
using LethalMin;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.AI;
using itolib.Behaviours.Grabbables;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: IgnoresAccessChecksTo("NoteBoxz.LethalMin")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("PikMoonsLib")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Library for PF1MIL's PikMoons mods.")]
[assembly: AssemblyFileVersion("0.0.1.0")]
[assembly: AssemblyInformationalVersion("0.0.1+71c1eac9e940d14f73b3565c0d7d918c06d5c8a0")]
[assembly: AssemblyProduct("PikMoonsLib")]
[assembly: AssemblyTitle("PikMoonsLib")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[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 PikMoonsLib
{
	[BepInPlugin("PF1MIL.PikMoonsLib", "PikMoonsLib", "0.0.1")]
	public class Plugin : BaseUnityPlugin
	{
		internal const string GUID = "PF1MIL.PikMoonsLib";

		internal const string PLUGIN_NAME = "PikMoonsLib";

		internal const string VERSION = "0.0.1";

		internal static ManualLogSource? StaticLogger { get; private set; }

		private void Awake()
		{
			StaticLogger = ((BaseUnityPlugin)this).Logger;
			try
			{
				ManualLogSource? staticLogger = StaticLogger;
				if (staticLogger != null)
				{
					staticLogger.LogInfo((object)"'PikMoonsLib' loaded!");
				}
			}
			catch (Exception arg)
			{
				StaticLogger.LogError((object)string.Format("Error while initializing '{0}': {1}", "PikMoonsLib", arg));
			}
		}
	}
}
namespace PikMoonsLib.Behaviours
{
	[RequireComponent(typeof(NavMeshAgent))]
	public class EnemyChaseAgent : MonoBehaviour
	{
		internal NavMeshAgent thisNavmeshAgent;

		internal EnemyAI currentTarget;

		public bool requireEnemyAlive = true;

		public void Awake()
		{
			NavMeshAgent val = default(NavMeshAgent);
			if (((Component)this).TryGetComponent<NavMeshAgent>(ref val))
			{
				thisNavmeshAgent = val;
			}
		}

		public void Update()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)currentTarget != (Object)null)
			{
				thisNavmeshAgent.SetDestination(((Component)currentTarget).gameObject.transform.position);
			}
		}

		public void SetEnemyTarget(EnemyAI enemyToChase)
		{
			if (!((Object)(object)currentTarget != (Object)null) && (!requireEnemyAlive || enemyToChase.enemyHP >= 1))
			{
				currentTarget = enemyToChase;
			}
		}
	}
	public class FreezeEffect : MonoBehaviour
	{
		public void FreezeEnemy(EnemyAI enemyToFreeze)
		{
			//IL_0015: 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)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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)
			PikminEnemy val = default(PikminEnemy);
			if (((Component)enemyToFreeze).TryGetComponent<PikminEnemy>(ref val))
			{
				PikminEnemy obj = val;
				Vector3 position = ((Component)val).transform.position;
				Quaternion rotation = ((Component)val).transform.rotation;
				obj.FreezeEnemyServerRpc(position, ((Quaternion)(ref rotation)).eulerAngles);
				PikminEnemy obj2 = val;
				Vector3 position2 = ((Component)val).transform.position;
				rotation = ((Component)val).transform.rotation;
				obj2.FreezeEnemy(position2, ((Quaternion)(ref rotation)).eulerAngles);
			}
			else
			{
				Plugin.StaticLogger.LogError((object)"PikminEnemy script could not be found.");
			}
		}
	}
	public class GrabbableDisabler : MonoBehaviour
	{
		private ItemGrabbable thisItem;

		private PikminItemSettings thisPikminItem;

		public void Awake()
		{
			thisItem = ((Component)this).GetComponent<ItemGrabbable>();
			PikminItemSettings val = default(PikminItemSettings);
			if (((Component)this).TryGetComponent<PikminItemSettings>(ref val))
			{
				thisPikminItem = val;
			}
		}

		public void GrabbableToEnemies(bool grabbable)
		{
			((GrabbableObject)thisItem).grabbableToEnemies = grabbable;
			if ((Object)(object)thisPikminItem != (Object)null)
			{
				thisPikminItem.OverrideGrabbableToEnemeis = grabbable;
			}
		}

		public void GrabbableToPikmin(bool grabbable)
		{
			thisPikminItem.GrabableToPikmin = grabbable;
		}
	}
	public class ReceiveShadowsOff : MonoBehaviour
	{
		public void ReceiveShadows(bool receiveShadows)
		{
			MeshRenderer val = default(MeshRenderer);
			if (((Component)((Component)this).transform).TryGetComponent<MeshRenderer>(ref val))
			{
				((Renderer)val).receiveShadows = receiveShadows;
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}