using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Photon.Pun;
using UnityEngine;
using UnityEngine.AI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("RevenantPlayer")]
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("RevenantPlayer")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("RevenantPlayer")]
[assembly: AssemblyVersion("1.0.0.0")]
[BepInPlugin("com.GameCorp.revenantplayer", "Revenant Player", "1.0.2")]
public class RevenantPlayer : BaseUnityPlugin
{
	public class RevenantInitializer
	{
		[RuntimeInitializeOnLoadMethod(/*Could not decode attribute arguments.*/)]
		private static void Init()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			if (!((Object)(object)Object.FindObjectOfType<RevenantBehaviour>() != (Object)null))
			{
				GameObject val = new GameObject("RevenantHandler");
				val.AddComponent<RevenantBehaviour>();
				Object.DontDestroyOnLoad((Object)(object)val);
			}
		}
	}

	public class RevenantBehaviour : MonoBehaviour
	{
		private void Update()
		{
			Instance?.HandleInput();
		}
	}

	[CompilerGenerated]
	private sealed class <DelayedRevenantRevive>d__11 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public PlayerAvatar avatar;

		public RevenantPlayer <>4__this;

		private MethodInfo <reviveMethod>5__1;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<reviveMethod>5__1 = ((object)avatar).GetType().GetMethod("Revive", BindingFlags.Instance | BindingFlags.Public);
				if (<reviveMethod>5__1 != null)
				{
					<reviveMethod>5__1.Invoke(avatar, new object[1] { false });
					BecomeRevenant(avatar);
				}
				else
				{
					log.LogError((object)"Méthode Revive introuvable.");
				}
				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 static RevenantPlayer Instance;

	public static ManualLogSource log;

	private static bool isRevenant = false;

	private static bool canRevive = true;

	private static bool transformed = false;

	public Material laserMaterial;

	private void Awake()
	{
		//IL_0027: 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_003d: Expected O, but got Unknown
		Instance = this;
		log = ((BaseUnityPlugin)this).Logger;
		log.LogInfo((object)"Revenant Player chargé.");
		new Harmony("com.GameCorp.revenantplayer").PatchAll();
		GameObject val = new GameObject("RevenantBehaviour");
		Object.DontDestroyOnLoad((Object)(object)val);
		val.AddComponent<RevenantBehaviour>();
	}

	private void HandleInput()
	{
		if (Input.GetKeyDown((KeyCode)107))
		{
			log.LogInfo((object)"Touche K pressée - test de mort");
			SimulateDeath();
		}
		if (isRevenant && !transformed && Input.GetKeyDown((KeyCode)103))
		{
			log.LogInfo((object)"Transformation Revenant déclenchée !");
			TransformToRevenant();
		}
		if (isRevenant && transformed && Input.GetMouseButtonDown(0))
		{
			log.LogInfo((object)"Attaque du Revenant !");
			Attack();
		}
	}

	private void SimulateDeath()
	{
		PlayerAvatar val = Object.FindObjectOfType<PlayerAvatar>();
		if ((Object)(object)val != (Object)null)
		{
			((object)val).GetType().GetMethod("PlayerDeath", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(val, new object[1] { -1 });
			((MonoBehaviour)this).StartCoroutine(DelayedRevenantRevive(val));
		}
		else
		{
			log.LogError((object)"PlayerAvatar non trouvé !");
		}
	}

	[IteratorStateMachine(typeof(<DelayedRevenantRevive>d__11))]
	private IEnumerator DelayedRevenantRevive(PlayerAvatar avatar)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <DelayedRevenantRevive>d__11(0)
		{
			<>4__this = this,
			avatar = avatar
		};
	}

	public static bool ShouldReviveAsRevenant()
	{
		return canRevive && Random.value <= 1f;
	}

	public static void BecomeRevenant(PlayerAvatar avatar)
	{
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_0165: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)avatar == (Object)null || isRevenant)
		{
			return;
		}
		isRevenant = true;
		transformed = false;
		log.LogInfo((object)"Le joueur est maintenant un Revenant !");
		if (!GameDirector.instance.PlayerList.Contains(avatar))
		{
			GameDirector.instance.PlayerList.Add(avatar);
		}
		GameObject gameObject = ((Component)avatar).gameObject;
		NavMeshHit val = default(NavMeshHit);
		if (NavMesh.SamplePosition(gameObject.transform.position, ref val, 2f, -1))
		{
			gameObject.transform.position = ((NavMeshHit)(ref val)).position;
		}
		else
		{
			log.LogWarning((object)"Impossible de repositionner le joueur sur une NavMesh !");
		}
		MonoBehaviour[] components = gameObject.GetComponents<MonoBehaviour>();
		foreach (MonoBehaviour val2 in components)
		{
			if ((Object)(object)val2 != (Object)null && !((Behaviour)val2).enabled)
			{
				((Behaviour)val2).enabled = true;
			}
		}
		CharacterController component = gameObject.GetComponent<CharacterController>();
		if ((Object)(object)component != (Object)null)
		{
			((Collider)component).enabled = true;
		}
		Rigidbody component2 = gameObject.GetComponent<Rigidbody>();
		if ((Object)(object)component2 != (Object)null)
		{
			component2.isKinematic = false;
		}
		NavMeshAgent component3 = gameObject.GetComponent<NavMeshAgent>();
		if ((Object)(object)component3 != (Object)null)
		{
			((Behaviour)component3).enabled = false;
			((Behaviour)component3).enabled = true;
			component3.Warp(gameObject.transform.position);
		}
		Cursor.lockState = (CursorLockMode)1;
		Cursor.visible = false;
		FieldInfo field = typeof(PlayerAvatar).GetField("isDead", BindingFlags.Instance | BindingFlags.NonPublic);
		if (field != null)
		{
			field.SetValue(avatar, false);
		}
		FieldInfo field2 = typeof(PlayerAvatar).GetField("health", BindingFlags.Instance | BindingFlags.NonPublic);
		if (field2 != null)
		{
			field2.SetValue(avatar, 100);
		}
		FieldInfo field3 = typeof(PlayerAvatar).GetField("stamina", BindingFlags.Instance | BindingFlags.NonPublic);
		if (field3 != null)
		{
			field3.SetValue(avatar, 100f);
		}
	}

	private void TransformToRevenant()
	{
		transformed = true;
		log.LogInfo((object)"Transformation réussie !");
	}

	private void Attack()
	{
		//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_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_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		if (isRevenant && transformed)
		{
			PlayerAvatar val = Object.FindObjectOfType<PlayerAvatar>();
			if (!((Object)(object)val == (Object)null))
			{
				log.LogInfo((object)"Revenant attaque avec le LaserManager !");
				Vector3 start = ((Component)val).transform.position + Vector3.up * 1.5f;
				Vector3 forward = ((Component)val).transform.forward;
				LaserManager.FireLaser(start, forward);
			}
		}
	}

	public static void UIShowHealth(float value)
	{
		log.LogInfo((object)$"[UI] Santé : {value}");
	}

	public static void UIShowEnergy(float value)
	{
		log.LogInfo((object)$"[UI] Énergie : {value}");
	}

	public static void UIShowInventory(string[] items)
	{
		log.LogInfo((object)("[UI] Inventaire : " + string.Join(", ", items)));
	}

	public static void UIShowAim(bool active)
	{
		log.LogInfo((object)$"[UI] Viseur actif : {active}");
	}
}
[HarmonyPatch]
public static class Patch_GameDirector_DeathStart
{
	[CompilerGenerated]
	private sealed class <DelayedRevive>d__2 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public PlayerAvatar avatar;

		private PhotonView <view>5__1;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(1.5f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				if (!((Component)avatar).gameObject.activeInHierarchy)
				{
					ManualLogSource log = RevenantPlayer.log;
					if (log != null)
					{
						log.LogWarning((object)"Avatar désactivé, réactivation forcée.");
					}
					((Component)avatar).gameObject.SetActive(true);
				}
				<view>5__1 = ((Component)avatar).GetComponent<PhotonView>();
				if ((Object)(object)<view>5__1 != (Object)null)
				{
					if ((Object)(object)((Component)avatar).GetComponent<RevenantNetworkHandler>() == (Object)null)
					{
						((Component)avatar).gameObject.AddComponent<RevenantNetworkHandler>();
					}
					<view>5__1.RPC("RevenantReviveRPC", (RpcTarget)0, Array.Empty<object>());
					ManualLogSource log2 = RevenantPlayer.log;
					if (log2 != null)
					{
						log2.LogInfo((object)"RevenantReviveRPC envoyé à tous les clients.");
					}
				}
				else
				{
					ManualLogSource log3 = RevenantPlayer.log;
					if (log3 != null)
					{
						log3.LogError((object)"PhotonView introuvable sur l'avatar !");
					}
				}
				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();
		}
	}

	private static MethodBase TargetMethod()
	{
		return AccessTools.Method("GameDirector:DeathStart", (Type[])null, (Type[])null);
	}

	private static bool Prefix()
	{
		if (RevenantPlayer.ShouldReviveAsRevenant())
		{
			ManualLogSource log = RevenantPlayer.log;
			if (log != null)
			{
				log.LogInfo((object)"Patch: Mort évitée. Devenu Revenant.");
			}
			PlayerAvatar val = Object.FindObjectOfType<PlayerAvatar>();
			if ((Object)(object)val == (Object)null)
			{
				Debug.LogError((object)"⚠\ufe0f avatar est NULL !");
				return true;
			}
			CoroutineRunner.Instance.RunCoroutine(DelayedRevive(val));
			return false;
		}
		return true;
	}

	[IteratorStateMachine(typeof(<DelayedRevive>d__2))]
	private static IEnumerator DelayedRevive(PlayerAvatar avatar)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <DelayedRevive>d__2(0)
		{
			avatar = avatar
		};
	}
}
public class CoroutineRunner : MonoBehaviour
{
	private static CoroutineRunner _instance;

	public static CoroutineRunner Instance
	{
		get
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			if ((Object)(object)_instance == (Object)null)
			{
				GameObject val = new GameObject("CoroutineRunner");
				Object.DontDestroyOnLoad((Object)(object)val);
				_instance = val.AddComponent<CoroutineRunner>();
			}
			return _instance;
		}
	}

	public void RunCoroutine(IEnumerator coroutine)
	{
		((MonoBehaviour)this).StartCoroutine(coroutine);
	}
}
public class LaserManager : MonoBehaviour
{
	public static void FireLaser(Vector3 start, Vector3 direction, float range = 100f, float duration = 0.3f)
	{
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0004: 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_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: 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_001c: 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_003d: Expected O, but got Unknown
		//IL_0051: 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)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Expected O, but got Unknown
		//IL_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0100: Unknown result type (might be due to invalid IL or missing references)
		//IL_010a: Expected O, but got Unknown
		//IL_0112: Unknown result type (might be due to invalid IL or missing references)
		bool flag = false;
		RaycastHit val = default(RaycastHit);
		Vector3 val2;
		if (Physics.Raycast(start, direction, ref val, range, -1))
		{
			val2 = ((RaycastHit)(ref val)).point;
			flag = true;
		}
		else
		{
			val2 = start + direction * range;
		}
		GameObject val3 = new GameObject("RevenantLaser");
		LineRenderer val4 = val3.AddComponent<LineRenderer>();
		val4.positionCount = 2;
		val4.SetPosition(0, start);
		val4.SetPosition(1, val2);
		val4.startWidth = 0.1f;
		val4.endWidth = 0.05f;
		((Renderer)val4).material = new Material(Shader.Find("Legacy Shaders/Particles/Additive"));
		((Renderer)val4).material.color = Color.red;
		val4.useWorldSpace = true;
		if (flag)
		{
			GameObject val5 = GameObject.CreatePrimitive((PrimitiveType)0);
			val5.transform.position = val2;
			val5.transform.localScale = Vector3.one * 0.2f;
			Renderer component = val5.GetComponent<Renderer>();
			component.material = new Material(Shader.Find("Legacy Shaders/Particles/Alpha Blended"));
			component.material.color = Color.yellow;
			Object.Destroy((Object)(object)val5.GetComponent<Collider>());
			Object.Destroy((Object)(object)val5, 0.4f);
		}
		Object.Destroy((Object)(object)val3, duration);
	}
}
public class RevenantNetworkHandler : MonoBehaviourPun
{
	[CompilerGenerated]
	private sealed class <WaitAndRevive>d__1 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public RevenantNetworkHandler <>4__this;

		private PlayerAvatar <avatar>5__1;

		private MethodInfo <reviveMethod>5__2;

		private Exception <ex>5__3;

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

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

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

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<avatar>5__1 = null;
			<reviveMethod>5__2 = null;
			<ex>5__3 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(0.5f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<avatar>5__1 = ((Component)<>4__this).GetComponent<PlayerAvatar>();
				if ((Object)(object)<avatar>5__1 == (Object)null)
				{
					ManualLogSource log = RevenantPlayer.log;
					if (log != null)
					{
						log.LogError((object)"RevenantReviveRPC: avatar introuvable !");
					}
					return false;
				}
				<reviveMethod>5__2 = ((object)<avatar>5__1).GetType().GetMethod("Revive", BindingFlags.Instance | BindingFlags.Public);
				if (<reviveMethod>5__2 != null)
				{
					try
					{
						<reviveMethod>5__2.Invoke(<avatar>5__1, new object[1] { false });
						RevenantPlayer.BecomeRevenant(<avatar>5__1);
					}
					catch (Exception ex)
					{
						<ex>5__3 = ex;
						ManualLogSource log2 = RevenantPlayer.log;
						if (log2 != null)
						{
							log2.LogError((object)("Erreur pendant Revive: " + <ex>5__3.Message + "\n" + <ex>5__3.StackTrace));
						}
					}
				}
				else
				{
					ManualLogSource log3 = RevenantPlayer.log;
					if (log3 != null)
					{
						log3.LogError((object)"Méthode Revive introuvable dans RPC.");
					}
				}
				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();
		}
	}

	[PunRPC]
	public void RevenantReviveRPC()
	{
		((MonoBehaviour)this).StartCoroutine(WaitAndRevive());
	}

	[IteratorStateMachine(typeof(<WaitAndRevive>d__1))]
	private IEnumerator WaitAndRevive()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <WaitAndRevive>d__1(0)
		{
			<>4__this = this
		};
	}
}