using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using Dawn;
using Dawn.Utils;
using Dusk;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using Unity.Netcode.Components;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Events;
using UnityEngine.SceneManagement;

[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("com.github.xuuxiaolan.yanderecuteamena")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("2.0.0.0")]
[assembly: AssemblyInformationalVersion("2.0.0+0aec61723227e99416559b61bbf8756a0fe710d1")]
[assembly: AssemblyProduct("YandereCuteamena")]
[assembly: AssemblyTitle("com.github.xuuxiaolan.yanderecuteamena")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.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.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]
	[Microsoft.CodeAnalysis.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]
	[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;
		}
	}
}
namespace YandereCuteamena
{
	[RequireComponent(typeof(SmartAgentNavigator))]
	[RequireComponent(typeof(Animator))]
	[RequireComponent(typeof(NetworkAnimator))]
	[RequireComponent(typeof(NetworkTransform))]
	[RequireComponent(typeof(Collider))]
	public abstract class AdvancedEnemyAI : EnemyAI
	{
		internal EnemyAI? targetEnemy;

		internal PlayerControllerB? previousTargetPlayer;

		[Header("Required Components")]
		[SerializeField]
		internal NetworkAnimator creatureNetworkAnimator;

		[SerializeField]
		internal SmartAgentNavigator smartAgentNavigator;

		[Header("Inherited Fields")]
		public AudioClip[] _hitBodySounds = Array.Empty<AudioClip>();

		public AudioClip spawnSound;

		[HideInInspector]
		public Random enemyRandom = new Random();

		public override void Start()
		{
			((EnemyAI)this).Start();
			enemyRandom = new Random(StartOfRound.Instance.randomMapSeed + RoundManager.Instance.SpawnedEnemies.Count + 69);
			if ((Object)(object)spawnSound != (Object)null)
			{
				base.creatureVoice.PlayOneShot(spawnSound);
			}
			smartAgentNavigator.OnUseEntranceTeleport.AddListener((UnityAction<bool>)((EnemyAI)this).SetEnemyOutside);
			smartAgentNavigator.SetAllValues(base.isOutside);
			GrabEnemyRarity(base.enemyType.enemyName);
		}

		public override void HitEnemy(int force = 1, PlayerControllerB? playerWhoHit = null, bool playHitSFX = false, int hitID = -1)
		{
			((EnemyAI)this).HitEnemy(force, playerWhoHit, playHitSFX, hitID);
			if (!base.isEnemyDead && playHitSFX && _hitBodySounds.Length != 0)
			{
				base.creatureSFX.PlayOneShot(_hitBodySounds[enemyRandom.Next(_hitBodySounds.Length)]);
			}
		}

		public void GrabEnemyRarity(string enemyName)
		{
			string enemyName2 = enemyName;
			SpawnableEnemyWithRarity val = ((IEnumerable<SpawnableEnemyWithRarity>)RoundManager.Instance.currentLevel.OutsideEnemies).FirstOrDefault((Func<SpawnableEnemyWithRarity, bool>)((SpawnableEnemyWithRarity x) => x.enemyType.enemyName.Equals(enemyName2))) ?? ((IEnumerable<SpawnableEnemyWithRarity>)RoundManager.Instance.currentLevel.DaytimeEnemies).FirstOrDefault((Func<SpawnableEnemyWithRarity, bool>)((SpawnableEnemyWithRarity x) => x.enemyType.enemyName.Equals(enemyName2))) ?? ((IEnumerable<SpawnableEnemyWithRarity>)RoundManager.Instance.currentLevel.Enemies).FirstOrDefault((Func<SpawnableEnemyWithRarity, bool>)((SpawnableEnemyWithRarity x) => x.enemyType.enemyName.Equals(enemyName2)));
			if (val != null)
			{
				YandereCuteamena.Logger.LogDebug((object)(enemyName2 + " has Rarity: " + val.rarity));
			}
			else
			{
				YandereCuteamena.Logger.LogWarning((object)"Enemy not found.");
			}
		}

		public bool FindClosestPlayerInRange(float range, bool targetAlreadyTargettedPerson = true)
		{
			//IL_007a: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB val = null;
			float num = float.MaxValue;
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val2 in allPlayerScripts)
			{
				if (((NetworkBehaviour)val2).IsSpawned && val2.isPlayerControlled && !val2.isPlayerDead && !val2.isInHangarShipRoom && EnemyHasLineOfSightToPosition(((Component)val2).transform.position, 60f, range) && !CheckIfPersonAlreadyTargetted(targetAlreadyTargettedPerson, val2))
				{
					float num2 = Vector3.Distance(((Component)this).transform.position, ((Component)val2).transform.position);
					if (num2 < num)
					{
						num = num2;
						val = val2;
					}
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			base.targetPlayer = val;
			return true;
		}

		public bool CheckIfPersonAlreadyTargetted(bool targetAlreadyTargettedPerson, PlayerControllerB playerToCheck)
		{
			if (!targetAlreadyTargettedPerson)
			{
				return false;
			}
			foreach (EnemyAI spawnedEnemy in RoundManager.Instance.SpawnedEnemies)
			{
				if (spawnedEnemy is AdvancedEnemyAI advancedEnemyAI && (Object)(object)((EnemyAI)advancedEnemyAI).targetPlayer == (Object)(object)playerToCheck)
				{
					return true;
				}
			}
			return false;
		}

		public bool EnemyHasLineOfSightToPosition(Vector3 pos, float width = 60f, float range = 20f, float proximityAwareness = 5f)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_003c: 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_0053: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			Transform val = ((!((Object)(object)base.eye == (Object)null)) ? base.eye : ((Component)this).transform);
			float num = Vector3.Distance(val.position, pos);
			if (num < proximityAwareness)
			{
				return true;
			}
			if (num >= range || Physics.Linecast(val.position, pos, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
			{
				return false;
			}
			Vector3 val2 = pos - val.position;
			return Vector3.Angle(val.forward, val2) < width;
		}

		public bool PlayerLookingAtEnemy(PlayerControllerB player, float dotProductThreshold)
		{
			//IL_0006: 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_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_0023: 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_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)
			//IL_004f: 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)
			Vector3 val = ((Component)this).transform.position - ((Component)player).gameObject.transform.position;
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			if (Vector3.Dot(((Component)player.gameplayCamera).transform.forward, normalized) < dotProductThreshold)
			{
				return false;
			}
			if (Physics.Linecast(((Component)player.gameplayCamera).transform.position, ((Component)this).transform.position, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
			{
				return false;
			}
			return true;
		}

		public bool EnemySeesPlayer(PlayerControllerB player, float dotThreshold)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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_0048: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			Transform val = ((!((Object)(object)base.eye == (Object)null)) ? ((Component)base.eye).transform : ((Component)this).transform);
			Vector3 val2 = ((Component)player).transform.position - val.position;
			Vector3 normalized = ((Vector3)(ref val2)).normalized;
			if (Vector3.Dot(((Component)this).transform.forward, normalized) < dotThreshold)
			{
				return false;
			}
			float num = Vector3.Distance(val.position, ((Component)player).transform.position);
			if (Physics.Raycast(val.position, normalized, num, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
			{
				return false;
			}
			return true;
		}

		[ServerRpc(RequireOwnership = false)]
		public void SetTargetServerRpc(int PlayerID)
		{
			SetTargetClientRpc(PlayerID);
		}

		[ClientRpc]
		public void SetTargetClientRpc(int PlayerID)
		{
			if (PlayerID == -1)
			{
				base.targetPlayer = null;
				PlayerSetAsTarget(null);
			}
			else if ((Object)(object)StartOfRound.Instance.allPlayerScripts[PlayerID] == (Object)null)
			{
				PlayerSetAsTarget(null);
			}
			else
			{
				previousTargetPlayer = base.targetPlayer;
				base.targetPlayer = StartOfRound.Instance.allPlayerScripts[PlayerID];
				PlayerSetAsTarget(base.targetPlayer);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SetEnemyTargetServerRpc(int enemyID)
		{
			SetEnemyTargetClientRpc(enemyID);
		}

		[ClientRpc]
		public void SetEnemyTargetClientRpc(int enemyID)
		{
			if (enemyID == -1)
			{
				targetEnemy = null;
				EnemySetAsTarget(null);
			}
			else if ((Object)(object)RoundManager.Instance.SpawnedEnemies[enemyID] == (Object)null)
			{
				EnemySetAsTarget(null);
			}
			else
			{
				targetEnemy = RoundManager.Instance.SpawnedEnemies[enemyID];
				EnemySetAsTarget(targetEnemy);
			}
		}

		public virtual void EnemySetAsTarget(EnemyAI? enemy)
		{
		}

		public virtual void PlayerSetAsTarget(PlayerControllerB? player)
		{
		}
	}
	public class CuteamenaEnemyAI : AdvancedEnemyAI
	{
		private enum CuteamenaState
		{
			Searching,
			Passive,
			Jealous,
			Yandere,
			Grief
		}

		private enum AttackType
		{
			Cleaver,
			Headbutt
		}

		[Header("Misc")]
		[SerializeField]
		private InteractTrigger _headPatTrigger;

		[SerializeField]
		private GameObject _cleaverGameObject;

		[Header("Stats")]
		[SerializeField]
		private float _wanderSpeed = 2f;

		[SerializeField]
		private float _followSpeed = 4f;

		[SerializeField]
		private float _chasingSpeed = 6f;

		[SerializeField]
		private int _healAmount = 10;

		[SerializeField]
		private float _healCooldown = 5f;

		[SerializeField]
		private float _attentionDistanceThreshold = 8f;

		[SerializeField]
		private float _jealousAttackRange = 5f;

		[SerializeField]
		private float _detectionRange = 20f;

		[SerializeField]
		private float _doorLockpickInterval = 200f;

		[SerializeField]
		private float _attackInterval = 5f;

		[SerializeField]
		private float _threatFindInterval = 2f;

		[Header("Audio")]
		[SerializeField]
		private AudioSource _griefingSource;

		[SerializeField]
		private AudioClip _cheerUpSound;

		[SerializeField]
		private AudioClip _yandereLaughSound;

		[SerializeField]
		private AudioClip[] _patSounds = Array.Empty<AudioClip>();

		[SerializeField]
		private AudioClip[] _footstepSounds = Array.Empty<AudioClip>();

		private PlayerControllerB? _chasingPlayer;

		private DoorLock? _targetDoor;

		private bool _isCleaverDrawn;

		private float _healTimer;

		private float _doorLockpickTimer;

		private float _attackTimer;

		private float _threatFindTimer;

		private static readonly int RunSpeedFloat = Animator.StringToHash("RunSpeed");

		private static readonly int IsDeadAnimation = Animator.StringToHash("isDead");

		private static readonly int CryingAnimation = Animator.StringToHash("crying");

		private static readonly int HitAnimation = Animator.StringToHash("hit");

		private static readonly int HeadbuttAnimation = Animator.StringToHash("headbutt");

		private static readonly int PetAnimation = Animator.StringToHash("pat");

		private static readonly int PullOutKnifeAnimation = Animator.StringToHash("pullOutKnife");

		private static readonly int SlashAnimation = Animator.StringToHash("slashAttack");

		public override void Start()
		{
			base.Start();
			((UnityEvent<PlayerControllerB>)(object)_headPatTrigger.onInteract).AddListener((UnityAction<PlayerControllerB>)OnHeadPatInteract);
			smartAgentNavigator.StartSearchRoutine(40f);
			((EnemyAI)this).agent.speed = _wanderSpeed;
			_healTimer = _healCooldown;
		}

		public override void Update()
		{
			((EnemyAI)this).Update();
			_headPatTrigger.interactable = ((EnemyAI)this).currentBehaviourStateIndex == 1 || ((EnemyAI)this).currentBehaviourStateIndex == 2;
			if (!((EnemyAI)this).isEnemyDead && ((NetworkBehaviour)this).IsServer)
			{
				_threatFindTimer -= Time.deltaTime;
				_healTimer -= Time.deltaTime;
				_doorLockpickTimer -= Time.deltaTime;
				_attackTimer -= Time.deltaTime;
			}
		}

		public override void DoAIInterval()
		{
			//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)
			((EnemyAI)this).DoAIInterval();
			if (!((EnemyAI)this).isEnemyDead && !StartOfRound.Instance.allPlayersDead)
			{
				Animator creatureAnimator = ((EnemyAI)this).creatureAnimator;
				int runSpeedFloat = RunSpeedFloat;
				Vector3 velocity = ((EnemyAI)this).agent.velocity;
				creatureAnimator.SetFloat(runSpeedFloat, ((Vector3)(ref velocity)).magnitude / 3f);
				switch (((EnemyAI)this).currentBehaviourStateIndex)
				{
				case 0:
					LookForSenpai();
					break;
				case 1:
					DoPassiveBehavior();
					break;
				case 2:
					DoJealousBehavior();
					break;
				case 3:
					DoYandereBehavior();
					break;
				case 4:
					DoGriefBehavior();
					break;
				}
			}
		}

		private void LookForSenpai()
		{
			//IL_0029: 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)
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (!val.isPlayerDead && val.isPlayerControlled && Vector3.Distance(((Component)this).transform.position, ((Component)val).transform.position) < _detectionRange)
				{
					((EnemyAI)this).agent.speed = _followSpeed;
					SetTargetServerRpc(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, val));
					((EnemyAI)this).SwitchToBehaviourServerRpc(1);
					break;
				}
			}
		}

		private void DoPassiveBehavior()
		{
			//IL_0196: 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_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)((EnemyAI)this).targetPlayer == (Object)null || ((EnemyAI)this).targetPlayer.isPlayerDead)
			{
				((EnemyAI)this).agent.speed = 0f;
				((EnemyAI)this).creatureAnimator.SetBool(CryingAnimation, true);
				((EnemyAI)this).SwitchToBehaviourServerRpc(4);
				return;
			}
			if ((Object)(object)targetEnemy != (Object)null)
			{
				if (targetEnemy.isEnemyDead)
				{
					SetEnemyTargetServerRpc(-1);
					return;
				}
				smartAgentNavigator.DoPathingToDestination(((Component)targetEnemy).transform.position);
				if (!(_attackTimer > 0f) && Vector3.Distance(((Component)this).transform.position, ((Component)targetEnemy).transform.position) < ((EnemyAI)this).agent.stoppingDistance)
				{
					_attackTimer = _attackInterval;
					creatureNetworkAnimator.SetTrigger(HeadbuttAnimation, true);
				}
				return;
			}
			if ((Object)(object)_targetDoor != (Object)null && _doorLockpickTimer <= 0f)
			{
				smartAgentNavigator.DoPathingToDestination(RoundManager.Instance.GetRandomNavMeshPositionInRadius(((Component)_targetDoor).transform.position, 2f, default(NavMeshHit)));
				if (Vector3.Distance(((Component)this).transform.position, ((Component)_targetDoor).transform.position) < ((EnemyAI)this).agent.stoppingDistance + 1f)
				{
					creatureNetworkAnimator.SetTrigger(HeadbuttAnimation, true);
					_doorLockpickTimer = _doorLockpickInterval;
				}
				return;
			}
			smartAgentNavigator.DoPathingToDestination(((Component)((EnemyAI)this).targetPlayer).transform.position);
			if (_healTimer <= 0f && ((EnemyAI)this).targetPlayer.health < 100)
			{
				HealSenpai();
				_healTimer = _healCooldown;
			}
			else if (_threatFindTimer <= 0f)
			{
				FindThreatsNearbySenpai();
				_threatFindTimer = _threatFindInterval;
			}
			else if (_doorLockpickTimer <= 0f)
			{
				ChooseDoorToLockpick();
				_doorLockpickTimer = _doorLockpickInterval;
			}
			else if (IsSenpaiIgnoringMe() || IsSenpaiWithOtherPlayers())
			{
				((EnemyAI)this).SwitchToBehaviourServerRpc(2);
			}
		}

		private void DoJealousBehavior()
		{
			if ((Object)(object)((EnemyAI)this).targetPlayer == (Object)null || ((EnemyAI)this).targetPlayer.isPlayerDead)
			{
				((EnemyAI)this).agent.speed = 0f;
				((EnemyAI)this).creatureAnimator.SetBool(CryingAnimation, true);
				((EnemyAI)this).SwitchToBehaviourServerRpc(4);
				return;
			}
			FollowSenpaiForwardly();
			float distanceToRival;
			PlayerControllerB val = LookForOtherPlayers(out distanceToRival);
			if ((Object)(object)val != (Object)null)
			{
				AttackPlayer(val, distanceToRival);
			}
			else if (HasBeenFurtherIgnored())
			{
				creatureNetworkAnimator.SetTrigger(PullOutKnifeAnimation, true);
				((EnemyAI)this).agent.speed = _chasingSpeed;
				((EnemyAI)this).SwitchToBehaviourServerRpc(3);
			}
		}

		private void DoYandereBehavior()
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			if (!_isCleaverDrawn)
			{
				return;
			}
			if ((Object)(object)_chasingPlayer == (Object)null)
			{
				float num = float.MaxValue;
				PlayerControllerB chasingPlayer = null;
				PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
				foreach (PlayerControllerB val in allPlayerScripts)
				{
					if (val.isPlayerControlled && !val.isPlayerDead)
					{
						chasingPlayer = val;
						num = Mathf.Min(num, Vector3.Distance(((Component)this).transform.position, ((Component)val).transform.position));
					}
				}
				if (num <= _detectionRange)
				{
					_chasingPlayer = chasingPlayer;
				}
			}
			else if (_chasingPlayer.isPlayerDead)
			{
				_chasingPlayer = null;
			}
			ChaseAndAttackPlayer(_chasingPlayer);
		}

		private void DoGriefBehavior()
		{
			if (HasSenpaiBodyBeenMoved())
			{
				creatureNetworkAnimator.SetTrigger(PullOutKnifeAnimation, true);
				((EnemyAI)this).agent.speed = _chasingSpeed;
				((EnemyAI)this).creatureAnimator.SetBool(CryingAnimation, false);
				((EnemyAI)this).SwitchToBehaviourServerRpc(3);
			}
		}

		private void OnHeadPatInteract(PlayerControllerB player)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)player != (Object)(object)((EnemyAI)this).targetPlayer))
			{
				HeadPatServerRpc(PlayerControllerReference.op_Implicit(player));
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void HeadPatServerRpc(PlayerControllerReference playerControllerReference)
		{
			PlayerControllerB val = PlayerControllerReference.op_Implicit(playerControllerReference);
			creatureNetworkAnimator.SetTrigger(PetAnimation, true);
			if (((EnemyAI)this).currentBehaviourStateIndex == 2 && !((Object)(object)val != (Object)(object)((EnemyAI)this).targetPlayer))
			{
				((EnemyAI)this).SwitchToBehaviourClientRpc(1);
			}
		}

		private void ChaseAndAttackPlayer(PlayerControllerB? player)
		{
			//IL_0016: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)player == (Object)null))
			{
				smartAgentNavigator.DoPathingToDestination(((Component)player).transform.position);
				if (Vector3.Distance(((Component)this).transform.position, ((Component)player).transform.position) < 2f)
				{
					creatureNetworkAnimator.SetTrigger(SlashAnimation, true);
				}
			}
		}

		private void FollowSenpaiForwardly()
		{
			//IL_000b: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ((Component)((EnemyAI)this).targetPlayer).transform.position + ((Component)((EnemyAI)this).targetPlayer).transform.forward * 2f;
			smartAgentNavigator.DoPathingToDestination(val);
		}

		private void HealSenpai()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			((EnemyAI)this).targetPlayer.DamagePlayerFromOtherClientServerRpc(-_healAmount, ((Component)this).transform.position, Array.IndexOf(StartOfRound.Instance.allPlayerScripts, ((EnemyAI)this).targetPlayer));
		}

		private void FindThreatsNearbySenpai()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			Collider[] array = Physics.OverlapSphere(((Component)((EnemyAI)this).targetPlayer).transform.position, 10f, LayerMask.GetMask(new string[1] { "Enemies" }), (QueryTriggerInteraction)2);
			Collider[] array2 = array;
			foreach (Collider val in array2)
			{
				EnemyAICollisionDetect component = ((Component)val).GetComponent<EnemyAICollisionDetect>();
				if (!((Object)(object)component == (Object)null) && component.mainScript.enemyType.canDie && !component.mainScript.isEnemyDead && !((Object)(object)component.mainScript.enemyType == (Object)(object)((EnemyAI)this).enemyType))
				{
					SetEnemyTargetServerRpc(RoundManager.Instance.SpawnedEnemies.IndexOf(component.mainScript));
					break;
				}
			}
		}

		private void ChooseDoorToLockpick()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			Collider[] array = Physics.OverlapSphere(((Component)this).transform.position, 10f, LayerMask.GetMask(new string[1] { "InteractableObject" }), (QueryTriggerInteraction)2);
			Collider[] array2 = array;
			foreach (Collider val in array2)
			{
				DoorLock component = ((Component)val).GetComponent<DoorLock>();
				if ((Object)(object)component != (Object)null && component.isLocked)
				{
					((Component)component).gameObject.GetComponent<NavMeshObstacle>().carving = false;
					_targetDoor = component;
					break;
				}
			}
		}

		private bool IsSenpaiIgnoringMe()
		{
			//IL_0006: 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)
			if (Vector3.Distance(((Component)this).transform.position, ((Component)((EnemyAI)this).targetPlayer).transform.position) > _attentionDistanceThreshold)
			{
				return !PlayerLookingAtEnemy(((EnemyAI)this).targetPlayer, 0.2f);
			}
			return false;
		}

		private bool IsSenpaiWithOtherPlayers()
		{
			//IL_0034: 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)
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (!((Object)(object)val == (Object)(object)((EnemyAI)this).targetPlayer) && !val.isPlayerDead && !(Vector3.Distance(((Component)((EnemyAI)this).targetPlayer).transform.position, ((Component)val).transform.position) > 5f))
				{
					return true;
				}
			}
			return false;
		}

		private PlayerControllerB? LookForOtherPlayers(out float distanceToRival)
		{
			//IL_003f: 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)
			distanceToRival = 0f;
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (!((Object)(object)val == (Object)(object)((EnemyAI)this).targetPlayer) && !val.isPlayerDead && val.isPlayerControlled)
				{
					distanceToRival = Vector3.Distance(((Component)this).transform.position, ((Component)val).transform.position);
					if (!(distanceToRival > _jealousAttackRange + 5f) && !IsSenpaiLookingAt(val))
					{
						return val;
					}
				}
			}
			return null;
		}

		private bool IsSenpaiLookingAt(PlayerControllerB player)
		{
			//IL_0006: 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)
			//IL_0028: 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_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)
			Vector3 val = ((Component)player).transform.position - ((Component)((EnemyAI)this).targetPlayer.gameplayCamera).transform.position;
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			float num = Vector3.Dot(((Component)((EnemyAI)this).targetPlayer.gameplayCamera).transform.forward, normalized);
			return num > 0.7f;
		}

		private bool HasBeenFurtherIgnored()
		{
			return Random.Range(0, 1000) < 2;
		}

		private void AttackPlayer(PlayerControllerB player, float distanceToRival)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			smartAgentNavigator.DoPathingToDestination(((Component)player).transform.position);
			if (!(distanceToRival < ((EnemyAI)this).agent.stoppingDistance + _jealousAttackRange))
			{
				creatureNetworkAnimator.SetTrigger(HeadbuttAnimation, true);
			}
		}

		private void AttackPlayerWithAttackType(PlayerControllerB player, AttackType attackType)
		{
			//IL_0016: 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_0039: 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)
			switch (attackType)
			{
			case AttackType.Cleaver:
				player.DamagePlayer(20, true, false, (CauseOfDeath)1, 0, false, ((Component)this).transform.forward * 10f);
				break;
			case AttackType.Headbutt:
				player.DamagePlayer(10, true, false, (CauseOfDeath)1, 0, false, ((Component)this).transform.forward * 10f);
				break;
			}
		}

		private bool HasSenpaiBodyBeenMoved()
		{
			if ((Object)(object)((EnemyAI)this).targetPlayer.deadBody == (Object)null)
			{
				return false;
			}
			DeadBodyInfo deadBody = ((EnemyAI)this).targetPlayer.deadBody;
			if (deadBody.grabBodyObject.isHeld)
			{
				return true;
			}
			return deadBody.bodyMovedThisFrame;
		}

		public void StartPatAnimEvent()
		{
			smartAgentNavigator.DisableMovement(true);
			smartAgentNavigator.StopAgent();
		}

		public void EndPatAnimEvent()
		{
			smartAgentNavigator.DisableMovement(false);
		}

		public void StartGriefingAnimEvent()
		{
			_ = _griefingSource.isPlaying;
		}

		public void FootstepSoundAnimEvent()
		{
			((EnemyAI)this).creatureSFX.PlayOneShot(_footstepSounds[enemyRandom.Next(_footstepSounds.Length)]);
		}

		public void DrawMeatCleaverAnimEvent()
		{
			_isCleaverDrawn = true;
			_cleaverGameObject.SetActive(true);
		}

		public void DropCleaverAnimEvent()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: 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)
			_isCleaverDrawn = false;
			_cleaverGameObject.SetActive(false);
			NetworkSingleton<CuteamenaUtils>.Instance.SpawnScrap(((Registry<DawnItemInfo>)(object)LethalContent.Items)[YandereCuteamenaItemKeys.Cleaver].Item, _cleaverGameObject.transform.position, defaultRotation: true, 0);
		}

		public void OnSwingCleaverAnimEvent()
		{
			if (!((Object)(object)_chasingPlayer == (Object)null))
			{
				AttackPlayerWithAttackType(_chasingPlayer, AttackType.Cleaver);
			}
		}

		public void HeadbuttAnimEvent()
		{
			if ((Object)(object)_targetDoor != (Object)null)
			{
				_targetDoor.UnlockDoor();
				((Component)_targetDoor).gameObject.GetComponent<NavMeshObstacle>().carving = true;
				_targetDoor = null;
			}
			else if ((Object)(object)_chasingPlayer != (Object)null)
			{
				AttackPlayerWithAttackType(_chasingPlayer, AttackType.Headbutt);
			}
			else if ((Object)(object)targetEnemy != (Object)null)
			{
				targetEnemy.HitEnemy(1, ((EnemyAI)this).targetPlayer, true, -1);
			}
		}

		public override void HitEnemy(int force = 1, PlayerControllerB? playerWhoHit = null, bool playHitSFX = false, int hitID = -1)
		{
			base.HitEnemy(force, playerWhoHit, playHitSFX, hitID);
			if (((EnemyAI)this).isEnemyDead)
			{
				return;
			}
			((EnemyAI)this).enemyHP = ((EnemyAI)this).enemyHP - force;
			if (((EnemyAI)this).enemyHP <= 0)
			{
				if (((NetworkBehaviour)this).IsOwner)
				{
					((EnemyAI)this).KillEnemyOnOwnerClient(false);
				}
				return;
			}
			if (((NetworkBehaviour)this).IsServer)
			{
				creatureNetworkAnimator.SetTrigger(HitAnimation, true);
			}
			if (!((Object)(object)playerWhoHit == (Object)null) && ((EnemyAI)this).currentBehaviourStateIndex != 3)
			{
				if (((EnemyAI)this).currentBehaviourStateIndex == 2)
				{
					creatureNetworkAnimator.SetTrigger(PullOutKnifeAnimation, true);
					((EnemyAI)this).agent.speed = _chasingSpeed;
					((EnemyAI)this).SwitchToBehaviourStateOnLocalClient(3);
				}
				else
				{
					((EnemyAI)this).SwitchToBehaviourStateOnLocalClient(2);
				}
			}
		}

		public override void KillEnemy(bool destroy = false)
		{
			((EnemyAI)this).KillEnemy(destroy);
			_cleaverGameObject.SetActive(false);
			if (((NetworkBehaviour)this).IsServer)
			{
				((EnemyAI)this).creatureAnimator.SetBool(IsDeadAnimation, true);
			}
		}
	}
	internal class CuteamenaUtils : NetworkSingleton<CuteamenaUtils>
	{
		[CompilerGenerated]
		private sealed class <ForceRotationForABit>d__3 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public GameObject go;

			public Quaternion rotation;

			private float <duration>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ForceRotationForABit>d__3(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<duration>5__2 = 0.25f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<duration>5__2 > 0f)
				{
					<duration>5__2 -= Time.deltaTime;
					go.transform.rotation = rotation;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public NetworkObjectReference SpawnScrap(Item? item, Vector3 position, bool defaultRotation, int valueIncrease, Quaternion rotation = default(Quaternion))
		{
			//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_0037: 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_0039: 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_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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: 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)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: 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_006e: 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_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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)StartOfRound.Instance == (Object)null || (Object)(object)item == (Object)null)
			{
				return default(NetworkObjectReference);
			}
			Transform val = null;
			if ((Object)(object)val == (Object)null)
			{
				val = StartOfRound.Instance.propsContainer;
			}
			Vector3 val2 = position;
			RaycastHit val3 = default(RaycastHit);
			if (Physics.Raycast(position + Vector3.up * 1f, Vector3.down, ref val3, 100f, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
			{
				val2 = ((RaycastHit)(ref val3)).point + Vector3.up * item.verticalOffset;
			}
			GameObject val4 = Object.Instantiate<GameObject>(item.spawnPrefab, val2 + Vector3.up * 0.2f, Quaternion.identity, val);
			GrabbableObject component = val4.GetComponent<GrabbableObject>();
			NetworkObject networkObject = ((NetworkBehaviour)component).NetworkObject;
			component.fallTime = 0f;
			networkObject.Spawn(false);
			UpdateParentAndRotationsServerRpc(new NetworkObjectReference(val4), defaultRotation ? Quaternion.Euler(item.restingRotation) : rotation);
			int num = (int)((float)Random.Range(item.minValue, item.maxValue) * RoundManager.Instance.scrapValueMultiplier) + valueIncrease;
			ScanNodeProperties componentInChildren = val4.GetComponentInChildren<ScanNodeProperties>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.scrapValue = num;
				componentInChildren.subText = $"Value: ${num}";
				component.scrapValue = num;
				UpdateScanNodeServerRpc(new NetworkObjectReference(networkObject), num);
			}
			return new NetworkObjectReference(val4);
		}

		[ServerRpc(RequireOwnership = false)]
		public void UpdateParentAndRotationsServerRpc(NetworkObjectReference go, Quaternion rotation)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			UpdateParentAndRotationsClientRpc(go, rotation);
		}

		[ClientRpc]
		public void UpdateParentAndRotationsClientRpc(NetworkObjectReference go, Quaternion rotation)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			NetworkObject val = default(NetworkObject);
			((NetworkObjectReference)(ref go)).TryGet(ref val, (NetworkManager)null);
			if ((Object)(object)val != (Object)null)
			{
				if (val.AutoObjectParentSync && ((NetworkBehaviour)this).IsServer)
				{
					((Component)val).transform.parent = StartOfRound.Instance.propsContainer;
				}
				else if (!val.AutoObjectParentSync)
				{
					((Component)val).transform.parent = StartOfRound.Instance.propsContainer;
				}
				((MonoBehaviour)this).StartCoroutine(ForceRotationForABit(((Component)val).gameObject, rotation));
			}
		}

		[IteratorStateMachine(typeof(<ForceRotationForABit>d__3))]
		private IEnumerator ForceRotationForABit(GameObject go, Quaternion rotation)
		{
			//IL_000e: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ForceRotationForABit>d__3(0)
			{
				go = go,
				rotation = rotation
			};
		}

		[ServerRpc(RequireOwnership = false)]
		public void UpdateScanNodeServerRpc(NetworkObjectReference go, int value)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			UpdateScanNodeClientRpc(go, value);
		}

		[ClientRpc]
		public void UpdateScanNodeClientRpc(NetworkObjectReference go, int value)
		{
			NetworkObject val = default(NetworkObject);
			((NetworkObjectReference)(ref go)).TryGet(ref val, (NetworkManager)null);
			GrabbableObject val2 = default(GrabbableObject);
			if ((Object)(object)val != (Object)null && ((Component)val).gameObject.TryGetComponent<GrabbableObject>(ref val2))
			{
				val2.SetScrapValue(value);
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal static class StartOfRoundPatch
	{
		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		public static void StartOfRound_Awake(ref StartOfRound __instance)
		{
			NetworkObjectExtensions.OnSpawn(((NetworkBehaviour)__instance).NetworkObject, (Action)CreateNetworkManager);
		}

		private static void CreateNetworkManager()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if ((((NetworkBehaviour)StartOfRound.Instance).IsServer || ((NetworkBehaviour)StartOfRound.Instance).IsHost) && (Object)(object)NetworkSingleton<CuteamenaUtils>.Instance == (Object)null)
			{
				GameObject val = Object.Instantiate<GameObject>(YandereCuteamena.Assets.UtilsPrefab);
				SceneManager.MoveGameObjectToScene(val, ((Component)StartOfRound.Instance).gameObject.scene);
				val.GetComponent<NetworkObject>().Spawn(false);
			}
		}
	}
	[BepInPlugin("com.github.xuuxiaolan.yanderecuteamena", "YandereCuteamena", "2.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class YandereCuteamena : BaseUnityPlugin
	{
		internal class MainAssets : AssetBundleLoader<MainAssets>
		{
			[LoadFromBundle("CuteamenaUtils.prefab")]
			public GameObject UtilsPrefab { get; private set; }

			public MainAssets(AssetBundle bundle)
				: base(bundle)
			{
			}
		}

		internal static readonly Harmony _harmony = new Harmony("com.github.xuuxiaolan.yanderecuteamena");

		internal static ManualLogSource Logger { get; private set; }

		public static DuskMod Mod { get; private set; }

		internal static MainAssets Assets { get; private set; } = null;


		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			_harmony.PatchAll(typeof(StartOfRoundPatch));
			AssetBundle val = AssetBundleUtils.LoadBundle(Assembly.GetExecutingAssembly(), "yanderecuteamenaassets");
			Assets = new MainAssets(val);
			Mod = DuskMod.RegisterMod((BaseUnityPlugin)(object)this, val);
			Mod.RegisterContentHandlers();
			Logger.LogInfo((object)"com.github.xuuxiaolan.yanderecuteamena v2.0.0 has loaded!");
		}
	}
	public class CuteamenaHandler : ContentHandler<CuteamenaHandler>
	{
		public class CuteamenaBundle : AssetBundleLoader<CuteamenaBundle>
		{
			public CuteamenaBundle(DuskMod mod, string filePath)
				: base(mod, filePath)
			{
			}
		}

		public CuteamenaBundle? Cuteamena;

		public CuteamenaHandler(DuskMod mod)
			: base(mod)
		{
			((ContentHandler)this).RegisterContent<CuteamenaBundle>("cuteaassets", ref Cuteamena, false);
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "com.github.xuuxiaolan.yanderecuteamena";

		public const string PLUGIN_NAME = "YandereCuteamena";

		public const string PLUGIN_VERSION = "2.0.0";
	}
	[GeneratedCode("DawnLib", "0.4.3")]
	public static class YandereCuteamenaEnemyKeys
	{
		public static NamespacedKey<DawnEnemyInfo> Cutea = NamespacedKey<DawnEnemyInfo>.From("yandere_cuteamena", "cutea");

		public static NamespacedKey<DawnEnemyInfo>? GetByReflection(string name)
		{
			return (NamespacedKey<DawnEnemyInfo>)(typeof(YandereCuteamenaEnemyKeys).GetField(name)?.GetValue(null));
		}
	}
	[GeneratedCode("DawnLib", "0.4.3")]
	public static class YandereCuteamenaItemKeys
	{
		public static NamespacedKey<DawnItemInfo> Cleaver = NamespacedKey<DawnItemInfo>.From("yandere_cuteamena", "cleaver");

		public static NamespacedKey<DawnItemInfo>? GetByReflection(string name)
		{
			return (NamespacedKey<DawnItemInfo>)(typeof(YandereCuteamenaItemKeys).GetField(name)?.GetValue(null));
		}
	}
}