using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using JetBrains.Annotations;
using LCTarrotCard.Cards;
using LCTarrotCard.Items;
using LCTarrotCard.Ressource;
using LCTarrotCard.Util;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Events;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("LCTarrotCard")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("LCTarrotCard")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("9457633A-7E87-4BDB-8892-B9C127F9C677")]
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.3.0")]
namespace LCTarrotCard
{
	[HarmonyPatch]
	public class Networker : NetworkBehaviour
	{
		public static bool AllowExtraLife;

		private static GameObject _networkPrefab;

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

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

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

		public static Networker Instance { get; private set; }

		[ServerRpc(RequireOwnership = false)]
		public void KillPlayerServerRpc(int playerId, Vector3 velocity, CauseOfDeath causeOfDeath)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			KillPlayerClientRpc(playerId, velocity, causeOfDeath);
		}

		[ClientRpc]
		public void KillPlayerClientRpc(int playerId, Vector3 velocity, CauseOfDeath causeOfDeath)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: 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_001d: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB obj = StartOfRound.Instance.allPlayerScripts[playerId];
			if (obj != null)
			{
				obj.KillPlayer(velocity, true, causeOfDeath, 0, default(Vector3));
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SetShipDoorStateServerRpc(bool opened)
		{
			SetShipDoorStateClientRpc(opened);
		}

		[ClientRpc]
		public void SetShipDoorStateClientRpc(bool opened)
		{
			HangarShipDoor[] array = Object.FindObjectsOfType<HangarShipDoor>();
			foreach (HangarShipDoor val in array)
			{
				if (opened)
				{
					val.SetDoorOpen();
					val.doorPower = 0f;
				}
				else
				{
					val.SetDoorClosed();
					val.doorPower = 100f;
				}
				val.shipDoorsAnimator.SetBool(Closed, !opened);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void OpenOrCloseRandomDoorServerRpc(int playerId)
		{
			OpenOrCloseRandomDoorClientRpc(playerId, new Random().Next());
		}

		[ClientRpc]
		public void OpenOrCloseRandomDoorClientRpc(int playerId, int rngSeed)
		{
			Random random = new Random(rngSeed);
			DoorLock[] array = Object.FindObjectsOfType<DoorLock>();
			foreach (DoorLock val in array)
			{
				if (random.Next(0, 2) == 0)
				{
					val.OpenOrCloseDoor(StartOfRound.Instance.allPlayerScripts[playerId]);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void BreakerOffServerRpc()
		{
			BreakerOffClientRpc();
		}

		[ClientRpc]
		public void BreakerOffClientRpc()
		{
			RoundManager.Instance.SwitchPower(false);
			BreakerBox[] array = Object.FindObjectsOfType<BreakerBox>();
			for (int i = 0; i < array.Length; i++)
			{
				array[i].SetSwitchesOff();
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void AgroCoilheadOrSpawnServerRpc()
		{
			SpringManAI[] array = Object.FindObjectsOfType<SpringManAI>();
			int num = 0;
			SpringManAI[] array2 = array;
			foreach (SpringManAI val in array2)
			{
				if (!((EnemyAI)val).isEnemyDead && ((NetworkBehaviour)val).IsSpawned)
				{
					num++;
					((EnemyAI)val).SwitchToBehaviourState(1);
				}
				if (num >= 2)
				{
					return;
				}
			}
			SpawnCoilheadServerRpc();
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpawnCoilheadServerRpc()
		{
			//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_0026: 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)
			EnemyVent[] array = Object.FindObjectsOfType<EnemyVent>();
			Vector3 position = array[Random.Range(0, array.Length)].floorNode.position;
			GameObject val = Object.Instantiate<GameObject>(Helper.Enemies.SpringMan.enemyPrefab, position, Quaternion.identity);
			val.GetComponentInChildren<NetworkObject>().Spawn(true);
			RoundManager.Instance.SpawnedEnemies.Add((EnemyAI)(object)val.GetComponent<SpringManAI>());
			((EnemyAI)val.GetComponent<SpringManAI>()).SetEnemyOutside(false);
			((EnemyAI)val.GetComponent<SpringManAI>()).SwitchToBehaviourState(1);
		}

		[ServerRpc(RequireOwnership = false)]
		public void PopOrSpawnJesterServerRpc(float popDelay)
		{
			//IL_0060: 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_0071: 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)
			bool flag = false;
			foreach (EnemyAI spawnedEnemy in RoundManager.Instance.SpawnedEnemies)
			{
				JesterAI val = (JesterAI)(object)((spawnedEnemy is JesterAI) ? spawnedEnemy : null);
				if (val != null && !((EnemyAI)val).isEnemyDead)
				{
					flag = true;
				}
			}
			if (!flag)
			{
				EnemyVent[] array = Object.FindObjectsOfType<EnemyVent>();
				Vector3 position = array[Random.Range(0, array.Length)].floorNode.position;
				GameObject val2 = Object.Instantiate<GameObject>(Helper.Enemies.Jester.enemyPrefab, position, Quaternion.identity);
				val2.GetComponentInChildren<NetworkObject>().Spawn(true);
				RoundManager.Instance.SpawnedEnemies.Add((EnemyAI)(object)val2.GetComponent<JesterAI>());
				((EnemyAI)val2.GetComponent<JesterAI>()).SetEnemyOutside(false);
				((EnemyAI)val2.GetComponent<JesterAI>()).SwitchToBehaviourState(1);
			}
			((MonoBehaviour)this).StartCoroutine(PopDelay(popDelay));
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpawnGiantOrDogServerRpc(int amount)
		{
			//IL_0022: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			GameObject[] array = GameObject.FindGameObjectsWithTag("OutsideAINode");
			for (int i = 0; i < amount; i++)
			{
				Vector3 position = array[Random.Range(0, array.Length)].transform.position;
				if (Random.Range(0, 2) == 0)
				{
					PluginLogger.Debug("Spawn giant");
					GameObject val = Object.Instantiate<GameObject>(Helper.Enemies.ForestGiant.enemyPrefab, position, Quaternion.identity);
					val.GetComponentInChildren<NetworkObject>().Spawn(true);
					RoundManager.Instance.SpawnedEnemies.Add((EnemyAI)(object)val.GetComponent<ForestGiantAI>());
					((EnemyAI)val.GetComponent<ForestGiantAI>()).SetEnemyOutside(true);
				}
				else
				{
					PluginLogger.Debug("Spawn dog");
					GameObject val2 = Object.Instantiate<GameObject>(Helper.Enemies.MouthDog.enemyPrefab, position, Quaternion.identity);
					val2.GetComponentInChildren<NetworkObject>().Spawn(true);
					RoundManager.Instance.SpawnedEnemies.Add((EnemyAI)(object)val2.GetComponent<MouthDogAI>());
					((EnemyAI)val2.GetComponent<MouthDogAI>()).SetEnemyOutside(true);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void TeleportRandomEntityServerRpc(Vector3 position, bool inside)
		{
			//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_00aa: Unknown result type (might be due to invalid IL or missing references)
			List<EnemyAI> spawnedEnemies = RoundManager.Instance.SpawnedEnemies;
			Helper.Shuffle(spawnedEnemies);
			using IEnumerator<EnemyAI> enumerator = spawnedEnemies.Where((EnemyAI enemy) => !enemy.isEnemyDead && enemy.isOutside == !inside && ((NetworkBehaviour)enemy).IsSpawned).GetEnumerator();
			if (enumerator.MoveNext())
			{
				EnemyAI current = enumerator.Current;
				PluginLogger.Debug("Enemy is outside ? " + current.isOutside + " player inside ? " + inside);
				string enemyName = current.enemyType.enemyName;
				Vector3 val = position;
				PluginLogger.Debug("Tp " + enemyName + " to " + ((object)(Vector3)(ref val)).ToString());
				TeleportEnemy(current, position);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void GhostBreatheServerRpc(Vector3 position)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			GhostBreatheClientRpc(position);
		}

		[ClientRpc]
		public void GhostBreatheClientRpc(Vector3 position)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			AudioSource.PlayClipAtPoint(Assets.GhostBreathe, position, 3f);
		}

		[ServerRpc(RequireOwnership = false)]
		public void TeleportEnemyAwayServerRpc()
		{
			//IL_0020: 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_0035: 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)
			foreach (EnemyAI spawnedEnemy in RoundManager.Instance.SpawnedEnemies)
			{
				Vector3 position = spawnedEnemy.ChooseFarthestNodeFromPosition(((Component)spawnedEnemy).transform.position, false, 0, false, 50, false).position;
				TeleportEnemy(spawnedEnemy, position);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void TeleportPlayerServerRpc(int playerId, Vector3 position, bool inside = true, bool insideShip = false)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			TeleportPlayerClientRpc(playerId, position, inside, insideShip);
		}

		[ClientRpc]
		public void TeleportPlayerClientRpc(int playerId, Vector3 position, bool inside = true, bool insideShip = false)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[playerId];
			val.StopSinkingServerRpc();
			if (Object.op_Implicit((Object)(object)val.currentTriggerInAnimationWith))
			{
				val.currentTriggerInAnimationWith.CancelAnimationExternally();
			}
			val.inSpecialInteractAnimation = false;
			val.isClimbingLadder = false;
			val.isInElevator = insideShip;
			val.isInHangarShipRoom = insideShip;
			val.isInsideFactory = inside;
			val.averageVelocity = 0f;
			val.velocityLastFrame = Vector3.zero;
			val.TeleportPlayer(position, false, 0f, false, true);
			val.beamOutParticle.Play();
			if (playerId == (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
			{
				HUDManager.Instance.ShakeCamera((ScreenShakeType)1);
			}
			if (Object.op_Implicit((Object)(object)Object.FindObjectOfType<AudioReverbPresets>()))
			{
				if (val.isInsideFactory)
				{
					Object.FindObjectOfType<AudioReverbPresets>().audioPresets[2].ChangeAudioReverbForPlayer(val);
				}
				else
				{
					Object.FindObjectOfType<AudioReverbPresets>().audioPresets[3].ChangeAudioReverbForPlayer(val);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SetPlayerHealthServerRpc(int playerId, int health)
		{
			SetPlayerHealthClientRpc(playerId, health);
		}

		[ClientRpc]
		public void SetPlayerHealthClientRpc(int playerId, int health)
		{
			if (health <= 0)
			{
				health = 1;
			}
			PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[playerId];
			int health2 = val.health;
			val.health = health;
			if (((NetworkBehaviour)val).IsOwner)
			{
				HUDManager.Instance.UpdateHealthUI(health, health2 > health);
				if (health <= 20 && !val.criticallyInjured)
				{
					HUDManager.Instance.ShakeCamera((ScreenShakeType)1);
					val.MakeCriticallyInjured(true);
				}
				else if (val.criticallyInjured && health > 20)
				{
					val.MakeCriticallyInjured(false);
				}
			}
			if (health2 > health)
			{
				return;
			}
			if (((NetworkBehaviour)val).IsOwner)
			{
				((MonoBehaviour)this).StartCoroutine(SetPlayerUI(val, health <= 20));
				((UnityEvent)StartOfRound.Instance.LocalPlayerDamagedEvent).Invoke();
				val.takingFallDamage = false;
				if (val.inSpecialInteractAnimation && !val.twoHandedAnimation)
				{
					val.playerBodyAnimator.SetTrigger(Damage);
				}
				val.specialAnimationWeight = 1f;
				val.PlayQuickSpecialAnimation(0.7f);
			}
			PlayerStats obj = val.playersManager.gameStats.allPlayerStats[val.playerClientId];
			obj.damageTaken += health2 - health;
			val.timeSinceTakingDamage = Time.realtimeSinceStartup;
		}

		[ServerRpc(RequireOwnership = false)]
		public void DamagePlayerServerRpc(int playerId, int damage, Vector3 velocity, CauseOfDeath causeOfDeath)
		{
			//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)
			DamagePlayerClientRpc(playerId, damage, velocity, causeOfDeath);
		}

		[ClientRpc]
		public void DamagePlayerClientRpc(int playerId, int damage, Vector3 velocity, CauseOfDeath causeOfDeath)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			StartOfRound.Instance.allPlayerScripts[playerId].DamagePlayer(damage, true, true, causeOfDeath, 0, false, velocity);
		}

		[ServerRpc(RequireOwnership = false)]
		public void MultiplyInventoryValueServerRpc(int playerId, float multiplier)
		{
			MultiplyInventoryValueClientRpc(playerId, multiplier);
		}

		[ClientRpc]
		public void MultiplyInventoryValueClientRpc(int playerId, float multiplier)
		{
			GrabbableObject[] itemSlots = StartOfRound.Instance.allPlayerScripts[playerId].ItemSlots;
			foreach (GrabbableObject obj in itemSlots)
			{
				obj.SetScrapValue((int)((float)obj.scrapValue * multiplier));
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void MultiplyRandomScrapValueServerRpc(float multiplier)
		{
			MultiplyRandomScrapValueClientRpc(multiplier, new Random().Next());
		}

		[ClientRpc]
		public void MultiplyRandomScrapValueClientRpc(float multiplier, int randomSeed)
		{
			Random random = new Random(randomSeed);
			GrabbableObject[] array = Object.FindObjectsOfType<GrabbableObject>();
			foreach (GrabbableObject val in array)
			{
				if (((Behaviour)val).enabled && val.itemProperties.isScrap && val.scrapValue > 0 && random.Next(0, 5) == 0)
				{
					val.SetScrapValue((int)((float)val.scrapValue * multiplier));
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void RevivePlayerServerRpc(int playerId)
		{
			RevivePlayerClientRpc(playerId);
		}

		[ClientRpc]
		public void RevivePlayerClientRpc(int playerId)
		{
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[playerId];
			if (!val.isPlayerDead && !val.isPlayerControlled)
			{
				return;
			}
			val.ResetPlayerBloodObjects(true);
			val.isClimbingLadder = false;
			val.clampLooking = false;
			val.inVehicleAnimation = false;
			val.disableMoveInput = false;
			val.ResetZAndXRotation();
			((Collider)val.thisController).enabled = true;
			val.health = 100;
			val.hasBeenCriticallyInjured = false;
			val.disableLookInput = false;
			val.disableInteract = false;
			if (val.isPlayerDead)
			{
				val.isPlayerDead = false;
				val.isPlayerControlled = true;
				val.isInElevator = true;
				val.isInHangarShipRoom = true;
				val.isInsideFactory = false;
				val.parentedToElevatorLastFrame = false;
				val.overrideGameOverSpectatePivot = null;
				StartOfRound.Instance.SetPlayerObjectExtrapolate(false);
				val.TeleportPlayer(StartOfRound.Instance.playerSpawnPositions[0].position, false, 0f, false, true);
				val.setPositionOfDeadPlayer = false;
				val.DisablePlayerModel(StartOfRound.Instance.allPlayerObjects[playerId], true, true);
				((Behaviour)val.helmetLight).enabled = false;
				val.Crouch(false);
				val.criticallyInjured = false;
				if (Object.op_Implicit((Object)(object)val.playerBodyAnimator))
				{
					val.playerBodyAnimator.SetBool(Limp, false);
				}
				val.bleedingHeavily = false;
				val.activatingItem = false;
				val.twoHanded = false;
				val.inShockingMinigame = false;
				val.inSpecialInteractAnimation = false;
				val.freeRotationInInteractAnimation = false;
				val.disableSyncInAnimation = false;
				val.inAnimationWithEnemy = null;
				val.holdingWalkieTalkie = false;
				val.speakingToWalkieTalkie = false;
				val.isSinking = false;
				val.isUnderwater = false;
				val.sinkingValue = 0f;
				val.statusEffectAudio.Stop();
				val.DisableJetpackControlsLocally();
				val.health = 100;
				val.mapRadarDotAnimator.SetBool("dead", false);
				val.externalForceAutoFade = Vector3.zero;
				if (((NetworkBehaviour)val).IsOwner)
				{
					HUDManager.Instance.gasHelmetAnimator.SetBool("gasEmitting", false);
					val.hasBegunSpectating = false;
					HUDManager.Instance.RemoveSpectateUI();
					HUDManager.Instance.gameOverAnimator.SetTrigger("revive");
					val.hinderedMultiplier = 1f;
					val.isMovementHindered = 0;
					val.sourcesCausingSinking = 0;
					val.reverbPreset = StartOfRound.Instance.shipReverb;
				}
			}
			if (((NetworkBehaviour)val).IsOwner)
			{
				SoundManager.Instance.earsRingingTimer = 0f;
				val.bleedingHeavily = false;
				val.criticallyInjured = false;
				val.playerBodyAnimator.SetBool(Limp, false);
				val.health = 100;
				HUDManager.Instance.UpdateHealthUI(100, false);
				val.spectatedPlayerScript = null;
				((Behaviour)HUDManager.Instance.audioListenerLowPass).enabled = false;
				StartOfRound.Instance.SetSpectateCameraToGameOverMode(false, val);
				((MonoBehaviour)this).StartCoroutine(SetPlayerUI(val));
			}
			val.voiceMuffledByEnemy = false;
			SoundManager.Instance.playerVoicePitchTargets[playerId] = 1f;
			SoundManager.Instance.SetPlayerPitch(1f, playerId);
			if (Object.op_Implicit((Object)(object)val.currentVoiceChatIngameSettings))
			{
				if (!Object.op_Implicit((Object)(object)val.currentVoiceChatIngameSettings.voiceAudio))
				{
					val.currentVoiceChatIngameSettings.InitializeComponents();
				}
				if (!Object.op_Implicit((Object)(object)val.currentVoiceChatIngameSettings.voiceAudio))
				{
					return;
				}
				((Component)val.currentVoiceChatIngameSettings.voiceAudio).GetComponent<OccludeAudio>().overridingLowPass = false;
			}
			RagdollGrabbableObject[] array = Object.FindObjectsOfType<RagdollGrabbableObject>();
			foreach (RagdollGrabbableObject val2 in array)
			{
				if (val2.ragdoll.playerObjectId != playerId)
				{
					continue;
				}
				if (!((GrabbableObject)val2).isHeld)
				{
					if (((NetworkBehaviour)this).IsServer)
					{
						if (((NetworkBehaviour)val2).NetworkObject.IsSpawned)
						{
							((NetworkBehaviour)val2).NetworkObject.Despawn(true);
						}
						else
						{
							Object.Destroy((Object)(object)((Component)val2).gameObject);
						}
					}
				}
				else if (Object.op_Implicit((Object)(object)((GrabbableObject)val2).playerHeldBy))
				{
					((GrabbableObject)val2).playerHeldBy.DropAllHeldItems(true, false);
				}
			}
			DeadBodyInfo[] array2 = Object.FindObjectsOfType<DeadBodyInfo>();
			foreach (DeadBodyInfo val3 in array2)
			{
				if (val3.playerObjectId == playerId)
				{
					Object.Destroy((Object)(object)((Component)val3).gameObject);
				}
			}
			StartOfRound instance = StartOfRound.Instance;
			instance.livingPlayers++;
			StartOfRound.Instance.allPlayersDead = false;
			StartOfRound.Instance.UpdatePlayerVoiceEffects();
		}

		[ServerRpc(RequireOwnership = false)]
		public void AllowExtraLifeServerRpc()
		{
			AllowExtraLifeClientRpc(allow: true);
		}

		[ClientRpc]
		public void AllowExtraLifeClientRpc(bool allow)
		{
			AllowExtraLife = allow;
		}

		[ServerRpc(RequireOwnership = false)]
		public void ExtraLifeServerRpc(int playerId)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if (AllowExtraLife)
			{
				PluginLogger.Debug("extra life " + StartOfRound.Instance.allPlayerScripts[playerId].playerUsername);
				AllowExtraLifeClientRpc(allow: false);
				TeleportPlayerServerRpc(playerId, StartOfRound.Instance.playerSpawnPositions[0].position, inside: false, insideShip: true);
				ExtraLifeClientRpc(playerId);
			}
		}

		[ClientRpc]
		public void ExtraLifeClientRpc(int playerId)
		{
			PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[playerId];
			val.health = 100;
			val.isPlayerDead = false;
			val.MakeCriticallyInjured(false);
			if (((NetworkBehaviour)val).IsOwner)
			{
				((MonoBehaviour)this).StartCoroutine(SetPlayerUI(val));
				HUDManager.Instance.UpdateHealthUI(100, false);
			}
			if (((NetworkBehaviour)StartOfRound.Instance.allPlayerScripts[playerId]).IsOwner)
			{
				HUDManager.Instance.DisplayTip("Extra life", "Thanks to the high priestess card, you are given an extra chance to live", false, false, "LC_Tip1");
			}
		}

		private static IEnumerator SetPlayerUI(PlayerControllerB player, bool critical = false)
		{
			yield return (object)new WaitForFixedUpdate();
			HUDManager.Instance.UpdateHealthUI(player.health, false);
			player.MakeCriticallyInjured(critical);
		}

		public static void TeleportEnemy(EnemyAI enemy, Vector3 position, bool exitEnter = false, bool outside = false)
		{
			//IL_0037: 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_0044: 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)
			//IL_0053: 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)
			if (exitEnter)
			{
				enemy.SetEnemyOutside(outside);
			}
			if (((NetworkBehaviour)enemy).OwnerClientId != GameNetworkManager.Instance.localPlayerController.actualClientId)
			{
				enemy.ChangeOwnershipOfEnemy(GameNetworkManager.Instance.localPlayerController.actualClientId);
			}
			Vector3 position2 = enemy.ChooseClosestNodeToPosition(position, false, 0).position;
			enemy.serverPosition = position2;
			((Component)enemy).transform.position = enemy.serverPosition;
			enemy.agent.Warp(enemy.serverPosition);
			enemy.SyncPositionToClients();
		}

		private static IEnumerator PopDelay(float delay)
		{
			yield return (object)new WaitForSeconds(delay);
			PluginLogger.Debug("Popping jesters");
			foreach (EnemyAI spawnedEnemy in RoundManager.Instance.SpawnedEnemies)
			{
				JesterAI val = (JesterAI)(object)((spawnedEnemy is JesterAI) ? spawnedEnemy : null);
				if (val != null && !((EnemyAI)val).isEnemyDead)
				{
					((EnemyAI)val).SwitchToBehaviourState(2);
				}
			}
		}

		public override void OnNetworkSpawn()
		{
			if ((Object)(object)NetworkManager.Singleton != (Object)null && (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer))
			{
				Networker instance = Instance;
				if (instance != null)
				{
					((Component)instance).gameObject.GetComponent<NetworkObject>().Despawn(true);
				}
			}
			Instance = this;
			((NetworkBehaviour)this).OnNetworkSpawn();
		}

		[HarmonyPatch(typeof(StartOfRound), "Awake")]
		[HarmonyPostfix]
		private static void SpawnNetHandler()
		{
			//IL_001e: 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)
			if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
			{
				Object.Instantiate<GameObject>(_networkPrefab, Vector3.zero, Quaternion.identity).GetComponent<NetworkObject>().Spawn(false);
			}
		}

		[HarmonyPatch(typeof(GameNetworkManager), "Start")]
		[HarmonyPostfix]
		private static void Init()
		{
			if (!((Object)(object)_networkPrefab != (Object)null))
			{
				_networkPrefab = Assets.Bundle.LoadAsset<GameObject>("Assets/Tarrot/Networker.prefab");
				_networkPrefab.AddComponent<Networker>();
				NetworkManager.Singleton.AddNetworkPrefab(_networkPrefab);
			}
		}
	}
	[BepInPlugin("LCTarotCard", "Phasmophobia Tarot Card", "1.0.3")]
	public class Plugin : BaseUnityPlugin
	{
		public static Plugin Instance;

		internal static KeyboardShortcut DebugBtn = new KeyboardShortcut((KeyCode)96, Array.Empty<KeyCode>());

		private Harmony harmony;

		public ManualLogSource logger;

		private void Awake()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			if (!((Object)(object)Instance != (Object)null))
			{
				Instance = this;
				logger = Logger.CreateLogSource("LCTarotCard");
				harmony = new Harmony("LCTarotCard");
				Assets.Load();
				AllCards.Init();
				harmony.PatchAll();
				NetcodePatcher();
			}
		}

		private static void NetcodePatcher()
		{
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			for (int i = 0; i < types.Length; i++)
			{
				MethodInfo[] methods = types[i].GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
				foreach (MethodInfo methodInfo in methods)
				{
					if (methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false).Length != 0)
					{
						methodInfo.Invoke(null, null);
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	internal class Test
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void TestPatch(PlayerControllerB __instance)
		{
		}
	}
	public static class PluginLogger
	{
		public static bool ShowDebug = true;

		public static void Debug(object o)
		{
			if (ShowDebug)
			{
				Plugin.Instance.logger.LogDebug((object)("[DEBUG] " + o));
			}
		}

		public static void Info(object o)
		{
			Plugin.Instance.logger.LogInfo(o);
		}

		public static void Error(object o)
		{
			Plugin.Instance.logger.LogError((object)("[ERROR] " + o));
		}

		public static void Warning(object o)
		{
			Plugin.Instance.logger.LogWarning((object)("[WARNING] " + o));
		}
	}
	public static class PluginConstants
	{
		public const string PLUGIN_GUID = "LCTarotCard";

		public const string PLUGIN_NAME = "Phasmophobia Tarot Card";

		public const string PLUGIN_VERSION = "1.0.3";

		internal const bool DEBUG_MODE = false;
	}
}
namespace LCTarrotCard.Util
{
	[HarmonyPatch]
	public class Helper
	{
		public static class Enemies
		{
			public static EnemyType Baboon;

			public static EnemyType Slime;

			public static EnemyType BushWolf;

			public static EnemyType Butler;

			public static EnemyType ButlerBees;

			public static EnemyType Centipede;

			public static EnemyType ClaySurgeon;

			public static EnemyType Crawler;

			public static EnemyType DocileLocust;

			public static EnemyType Manticoil;

			public static EnemyType DressGirl;

			public static EnemyType FlowerMan;

			public static EnemyType FlowerSnake;

			public static EnemyType ForestGiant;

			public static EnemyType HoarderBug;

			public static EnemyType Jester;

			public static EnemyType LassoMan;

			public static EnemyType Masked;

			public static EnemyType MouthDog;

			public static EnemyType Nutcracker;

			public static EnemyType Puffer;

			public static EnemyType RadMech;

			public static EnemyType RedLocust;

			public static EnemyType RedPill;

			public static EnemyType Spider;

			public static EnemyType SandWorm;

			public static EnemyType SpringMan;

			public static readonly List<EnemyType> AllEnemies = new List<EnemyType>();

			public static readonly List<EnemyType> SpawnableEnemies = new List<EnemyType>();

			[CanBeNull]
			public static EnemyType GetByName(string name)
			{
				return ((IEnumerable<EnemyType>)AllEnemies).FirstOrDefault((Func<EnemyType, bool>)((EnemyType enemy) => enemy.enemyName == name));
			}
		}

		private static readonly Random Rng = new Random();

		public static void InitEnemies()
		{
			PluginLogger.Debug("InitEnemies");
			EnemyType[] array = Resources.FindObjectsOfTypeAll<EnemyType>().Concat(Object.FindObjectsByType<EnemyType>((FindObjectsInactive)1, (FindObjectsSortMode)1)).ToArray();
			PluginLogger.Debug("Found " + array.Length + " enemies");
			EnemyType[] array2 = array;
			foreach (EnemyType val in array2)
			{
				PluginLogger.Debug("Found enemy : " + val.enemyName);
				if (!Enemies.AllEnemies.Contains(val))
				{
					Enemies.AllEnemies.Add(val);
					if (val.enemyName != "Lasso" || val.enemyName != "Red pill")
					{
						Enemies.SpawnableEnemies.Add(val);
					}
				}
				switch (val.enemyName)
				{
				case "Baboon hawk":
					Enemies.Baboon = val;
					break;
				case "Blob":
					Enemies.Slime = val;
					break;
				case "Bush Wolf":
					Enemies.BushWolf = val;
					break;
				case "Butler":
					Enemies.Butler = val;
					break;
				case "Butler Bees":
					Enemies.ButlerBees = val;
					break;
				case "Centipede":
					Enemies.Centipede = val;
					break;
				case "Clay Surgeon":
					Enemies.ClaySurgeon = val;
					break;
				case "Crawler":
					Enemies.Crawler = val;
					break;
				case "Docile Locust Bees":
					Enemies.DocileLocust = val;
					break;
				case "Manticoil":
					Enemies.Manticoil = val;
					break;
				case "Girl":
					Enemies.DressGirl = val;
					break;
				case "Flowerman":
					Enemies.FlowerMan = val;
					break;
				case "Tulip Snake":
					Enemies.FlowerSnake = val;
					break;
				case "ForestGiant":
					Enemies.ForestGiant = val;
					break;
				case "Hoarding bug":
					Enemies.HoarderBug = val;
					break;
				case "Jester":
					Enemies.Jester = val;
					break;
				case "Lasso":
					Enemies.LassoMan = val;
					break;
				case "Masked":
					Enemies.Masked = val;
					break;
				case "MouthDog":
					Enemies.MouthDog = val;
					break;
				case "Nutcracker":
					Enemies.Nutcracker = val;
					break;
				case "Puffer":
					Enemies.Puffer = val;
					break;
				case "RadMech":
					Enemies.RadMech = val;
					break;
				case "Red Locust Bees":
					Enemies.RedLocust = val;
					break;
				case "Red pill":
					Enemies.RedPill = val;
					break;
				case "Bunker Spider":
					Enemies.Spider = val;
					break;
				case "Earth Leviathan":
					Enemies.SandWorm = val;
					break;
				case "Spring":
					Enemies.SpringMan = val;
					break;
				}
			}
		}

		public static void Shuffle<T>(IList<T> list)
		{
			int num = list.Count;
			while (num > 1)
			{
				num--;
				int num2 = Rng.Next(num + 1);
				int index = num2;
				int index2 = num;
				T value = list[num];
				T value2 = list[num2];
				list[index] = value;
				list[index2] = value2;
			}
		}

		public static GameObject ClosestAINode(Vector3 position, bool inside)
		{
			//IL_0032: 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)
			GameObject[] obj = (inside ? GameObject.FindGameObjectsWithTag("AINode") : GameObject.FindGameObjectsWithTag("OutsideAINode"));
			GameObject result = null;
			float num = float.MaxValue;
			GameObject[] array = obj;
			foreach (GameObject val in array)
			{
				float num2 = Vector3.Distance(val.transform.position, position);
				if (num2 < num)
				{
					num = num2;
					result = val;
				}
			}
			return result;
		}

		[HarmonyPatch(typeof(StartOfRound), "Start")]
		[HarmonyPostfix]
		private static void InitEnemiesPatch()
		{
			InitEnemies();
		}
	}
	public enum Planet
	{
		Experimentation,
		Assurance,
		Vow,
		Gordion,
		March,
		Adamance,
		Rend,
		Dine,
		Offense,
		Titan,
		Artifice,
		Liquidation,
		Embrion
	}
	public class SpawnRarity
	{
		private readonly int defaultValue;

		private readonly Item item;

		private readonly Dictionary<Planet, int> rarities = new Dictionary<Planet, int>();

		public SpawnRarity(int baseValue, Item itemIn)
		{
			item = itemIn;
			defaultValue = baseValue;
			foreach (Planet value in Enum.GetValues(typeof(Planet)))
			{
				rarities.Add(value, baseValue);
			}
		}

		public int GetRarityFor(Planet planet)
		{
			return rarities[planet];
		}

		public int GetRarityFor(int planet)
		{
			return rarities.Values.ToList()[planet];
		}

		public void SetValues(int experimentation = -1, int assurance = -1, int vow = -1, int march = -1, int offense = -1, int adamance = -1, int rend = -1, int dine = -1, int titan = -1, int artifice = -1, int embrion = -1)
		{
			rarities[Planet.Experimentation] = experimentation;
			rarities[Planet.Assurance] = assurance;
			rarities[Planet.Vow] = vow;
			rarities[Planet.March] = march;
			rarities[Planet.Offense] = offense;
			rarities[Planet.Adamance] = adamance;
			rarities[Planet.Rend] = rend;
			rarities[Planet.Dine] = dine;
			rarities[Planet.Titan] = titan;
			rarities[Planet.Artifice] = artifice;
			rarities[Planet.Embrion] = embrion;
		}

		public void CopyRaritiesFrom(SpawnRarity other)
		{
			rarities[Planet.Experimentation] = other.rarities[Planet.Experimentation];
			rarities[Planet.Assurance] = other.rarities[Planet.Assurance];
			rarities[Planet.Vow] = other.rarities[Planet.Vow];
			rarities[Planet.March] = other.rarities[Planet.March];
			rarities[Planet.Offense] = other.rarities[Planet.Offense];
			rarities[Planet.Adamance] = other.rarities[Planet.Adamance];
			rarities[Planet.Rend] = other.rarities[Planet.Rend];
			rarities[Planet.Dine] = other.rarities[Planet.Dine];
			rarities[Planet.Titan] = other.rarities[Planet.Titan];
			rarities[Planet.Artifice] = other.rarities[Planet.Artifice];
			rarities[Planet.Embrion] = other.rarities[Planet.Embrion];
		}

		public SpawnableItemWithRarity GetSpawnableItemForPlanet(Planet planet)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			return new SpawnableItemWithRarity
			{
				spawnableItem = item,
				rarity = AccessRaritySafe((int)planet)
			};
		}

		public SpawnableItemWithRarity GetSpawnableItemForPlanet(int planet)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			return new SpawnableItemWithRarity
			{
				spawnableItem = item,
				rarity = AccessRaritySafe(planet)
			};
		}

		private int AccessRaritySafe(int planet)
		{
			try
			{
				return rarities.Values.ToList()[planet];
			}
			catch (Exception)
			{
			}
			return defaultValue;
		}

		public void ApplySpawnRarity(SelectableLevel level)
		{
			level.spawnableScrap.Add(GetSpawnableItemForPlanet(level.levelID));
		}
	}
}
namespace LCTarrotCard.Ressource
{
	public static class Assets
	{
		public static class Materials
		{
			public static Material CardDeathMat;

			public static Material CardHangedMat;

			public static Material CardPriestessMat;

			public static Material CardDevilMat;

			public static Material CardFoolMat;

			public static Material CardHermitMat;

			public static Material CardMoonMat;

			public static Material CardSunMat;

			public static Material CardTowerMat;

			public static Material CardWheelMat;

			public static Material BurnAqua;

			public static Material BurnBlue;

			public static Material BurnGreen;

			public static Material BurnPurple;

			public static Material BurnRed;

			public static Material BurnWhite;

			public static Material BurnYellow;
		}

		internal static AssetBundle Bundle;

		public static Item TarotItem;

		public static GameObject SingleTarotCard;

		public static readonly List<AudioClip> PullCardClips = new List<AudioClip>();

		public static AudioClip FoolCardSound;

		public static AudioClip GhostBreathe;

		public static SpawnRarity TarotRarity;

		public static void Load()
		{
			if (LoadBundle())
			{
				LoadAssets();
				InitSpawns();
			}
		}

		private static bool LoadBundle()
		{
			Stream manifestResourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("LCTarrotCard.Ressource.tarrotbundle");
			if (manifestResourceStream == null)
			{
				PluginLogger.Error("Cannot load the asset bundle");
				return false;
			}
			Bundle = AssetBundle.LoadFromStream(manifestResourceStream);
			if ((Object)(object)Bundle != (Object)null)
			{
				return true;
			}
			PluginLogger.Error("Cannot load the asset bundle");
			return false;
		}

		private static void LoadAssets()
		{
			TarotItem = LoadAsset<Item>("TarrotCard.asset");
			TarotBehaviour tarotBehaviour = TarotItem.spawnPrefab.AddComponent<TarotBehaviour>();
			((GrabbableObject)tarotBehaviour).grabbable = true;
			((GrabbableObject)tarotBehaviour).grabbableToEnemies = true;
			((GrabbableObject)tarotBehaviour).itemProperties = TarotItem;
			SingleTarotCard = LoadAsset<GameObject>("single_card_prefab.prefab");
			PullCardClips.Add(LoadAsset<AudioClip>("Sound/tarot_draw1.ogg"));
			PullCardClips.Add(LoadAsset<AudioClip>("Sound/tarot_draw2.ogg"));
			PullCardClips.Add(LoadAsset<AudioClip>("Sound/tarot_draw3.ogg"));
			FoolCardSound = LoadAsset<AudioClip>("Sound/fool.ogg");
			GhostBreathe = LoadAsset<AudioClip>("Sound/breathe.ogg");
			LoadMaterials();
		}

		private static void LoadMaterials()
		{
			Materials.CardDeathMat = LoadAsset<Material>("Cards/DeathMat.mat");
			Materials.CardHangedMat = LoadAsset<Material>("Cards/HangedManMat.mat");
			Materials.CardPriestessMat = LoadAsset<Material>("Cards/HighPreistessMat.mat");
			Materials.CardDevilMat = LoadAsset<Material>("Cards/TheDevilMat.mat");
			Materials.CardFoolMat = LoadAsset<Material>("Cards/TheFoolMat.mat");
			Materials.CardHermitMat = LoadAsset<Material>("Cards/TheHermitMat.mat");
			Materials.CardMoonMat = LoadAsset<Material>("Cards/TheMoonMat.mat");
			Materials.CardSunMat = LoadAsset<Material>("Cards/TheSunMat.mat");
			Materials.CardTowerMat = LoadAsset<Material>("Cards/TowerMat.mat");
			Materials.CardWheelMat = LoadAsset<Material>("Cards/WheelMat.mat");
			Materials.BurnAqua = LoadAsset<Material>("Burn/AquaBurn.mat");
			Materials.BurnBlue = LoadAsset<Material>("Burn/BlueBurn.mat");
			Materials.BurnGreen = LoadAsset<Material>("Burn/GreenBurn.mat");
			Materials.BurnPurple = LoadAsset<Material>("Burn/PurpleBurn.mat");
			Materials.BurnRed = LoadAsset<Material>("Burn/RedBurn.mat");
			Materials.BurnWhite = LoadAsset<Material>("Burn/WhiteBurn.mat");
			Materials.BurnYellow = LoadAsset<Material>("Burn/YellowBurn.mat");
		}

		private static void InitSpawns()
		{
			TarotRarity = new SpawnRarity(17, TarotItem);
			TarotRarity.SetValues(12, -1, 19, 21, -1, 22, 22, 23, 30, 25, 20);
		}

		private static T LoadAsset<T>(string assetPath) where T : Object
		{
			return Bundle.LoadAsset<T>("Assets/Tarrot/" + assetPath);
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager))]
	internal class NetworkPatcher
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void RegisterNetworkPrefab()
		{
			NetworkManager component = ((Component)GameNetworkManager.Instance).GetComponent<NetworkManager>();
			component.AddNetworkPrefab(Assets.TarotItem.spawnPrefab);
			component.AddNetworkPrefab(Assets.SingleTarotCard);
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal class StartOfRoundPatcher
	{
		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void RegisterItemsPatch(StartOfRound __instance)
		{
			SelectableLevel[] levels = __instance.levels;
			foreach (SelectableLevel level in levels)
			{
				Assets.TarotRarity.ApplySpawnRarity(level);
			}
			RegisterItem(Assets.TarotItem, __instance);
		}

		private static void RegisterItem(Item item, StartOfRound manager)
		{
			if (!manager.allItemsList.itemsList.Contains(item))
			{
				manager.allItemsList.itemsList.Add(item);
			}
		}
	}
}
namespace LCTarrotCard.Patches
{
	[HarmonyPatch(typeof(PlayerControllerB))]
	public class PlayerControllerBPatch
	{
		[HarmonyPatch("KillPlayer")]
		[HarmonyPrefix]
		private static bool AllowExtraLife(PlayerControllerB __instance)
		{
			if (!Networker.AllowExtraLife || !((NetworkBehaviour)__instance).IsOwner)
			{
				return true;
			}
			PluginLogger.Debug("Allowing extra life for player " + __instance.playerUsername);
			Networker.Instance.ExtraLifeServerRpc((int)__instance.playerClientId);
			return false;
		}
	}
}
namespace LCTarrotCard.Items
{
	public class TarotBehaviour : GrabbableObject
	{
		private readonly AnimationCurve controlCurve = new AnimationCurve((Keyframe[])(object)new Keyframe[2]
		{
			new Keyframe(0f, 0f, 0f, 0f, 0.5f, 0.5f),
			new Keyframe(1f, 1f, 0f, 0f, 0.5f, 0.5f)
		});

		private int cardLeft = 10;

		private GameObject currentCard;

		private Card currentCardProperties;

		private bool drawingCoroutinePlaying;

		private bool isDrawingCard;

		private AudioSource itemAudio;

		private Vector3 originalCardScale;

		private PlayerControllerB playerWhoDrew;

		public override void Start()
		{
			//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)
			((GrabbableObject)this).Start();
			itemAudio = ((Component)this).gameObject.GetComponent<AudioSource>();
			originalCardScale = ((Component)this).gameObject.transform.localScale;
		}

		public override void ItemActivate(bool used, bool buttonDown = true)
		{
			if (!base.deactivated && StartOfRound.Instance.shipHasLanded && ((NetworkBehaviour)this).IsOwner && buttonDown && !isDrawingCard && base.isHeld && !((Object)(object)base.playerHeldBy == (Object)null) && cardLeft > 0)
			{
				isDrawingCard = true;
				DrawCardServerRpc(base.playerHeldBy.playerClientId);
			}
		}

		public override void SetControlTipsForItem()
		{
			List<string> list = new List<string>(base.itemProperties.toolTips);
			if (cardLeft > 0)
			{
				list.Add(cardLeft + " card" + ((cardLeft == 1) ? "" : "s") + " left");
			}
			HUDManager.Instance.ChangeControlTipMultiple(list.ToArray(), true, base.itemProperties);
		}

		public void StartDrawingCard(int pulledCard)
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: 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_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)playerWhoDrew == (Object)null)
			{
				PluginLogger.Error("Trying to pull a card with a null player");
				DestroyAfterDrawing();
				return;
			}
			if (pulledCard < 0 || pulledCard >= AllCards.GetAllCardsAsList().Count)
			{
				PluginLogger.Error("Trying to pull a card with an invalid index");
				DestroyAfterDrawing();
				return;
			}
			cardLeft--;
			PluginLogger.Debug("Card left : " + cardLeft);
			((GrabbableObject)this).SetControlTipsForItem();
			if (cardLeft > 0)
			{
				float num = (float)cardLeft * 0.1f;
				Vector3 val = default(Vector3);
				((Vector3)(ref val))..ctor(originalCardScale.x, originalCardScale.y * num, originalCardScale.z);
				((Component)this).gameObject.transform.localScale = val;
				base.originalScale = val;
			}
			else
			{
				((Component)((Component)this).gameObject.transform.GetChild(0)).gameObject.SetActive(false);
			}
			if (!drawingCoroutinePlaying)
			{
				Type type = AllCards.GetAllCardsAsList()[pulledCard];
				currentCard = Object.Instantiate<GameObject>(Assets.SingleTarotCard, ((Component)this).gameObject.transform);
				Transform transform = currentCard.transform;
				transform.localEulerAngles += new Vector3(180f, 0f, 0f);
				PluginLogger.Debug("Card with type " + type.Name);
				currentCardProperties = (Card)Activator.CreateInstance(type, currentCard, itemAudio);
				currentCardProperties.InitCard();
				((MonoBehaviour)this).StartCoroutine(DrawingCoroutine());
			}
		}

		private IEnumerator DrawingCoroutine()
		{
			drawingCoroutinePlaying = true;
			((MonoBehaviour)this).StartCoroutine(currentCardProperties.CardPullingCoroutine());
			yield return (object)new WaitForSeconds(0.5f);
			Vector3 initPos = currentCard.transform.localPosition;
			Vector3 endPos = currentCard.transform.localPosition + new Vector3(0.2f, 0f, 0f);
			float delta = 0f;
			while (delta < 0.5f)
			{
				currentCard.transform.localPosition = Vector3.Lerp(initPos, endPos, controlCurve.Evaluate(delta * 2f));
				delta += Time.deltaTime;
				yield return null;
			}
			yield return (object)new WaitForSeconds(1.1f);
			if (((NetworkBehaviour)this).IsOwner)
			{
				try
				{
					currentCardProperties.ExecuteEffect(playerWhoDrew);
				}
				catch (Exception ex)
				{
					PluginLogger.Error("Error while executing card effect : " + ex);
				}
			}
			yield return (object)new WaitForSeconds(1f);
			drawingCoroutinePlaying = false;
			EndDrawingCard();
		}

		public void EndDrawingCard()
		{
			if (!drawingCoroutinePlaying)
			{
				DestroyAfterDrawing();
			}
		}

		private void DestroyAfterDrawing()
		{
			playerWhoDrew = null;
			if (Object.op_Implicit((Object)(object)currentCard))
			{
				Object.Destroy((Object)(object)currentCard);
			}
			currentCardProperties = null;
			if (cardLeft <= 0)
			{
				DestroyServerRpc();
			}
			isDrawingCard = false;
		}

		private void DestroyLocalClient()
		{
			itemAudio.volume = 0f;
			((GrabbableObject)this).DestroyObjectInHand(base.playerHeldBy);
			base.deactivated = true;
		}

		[ServerRpc]
		public void DestroyServerRpc()
		{
			if (!((NetworkBehaviour)this).IsHost)
			{
				DestroyLocalClient();
			}
			DestroyClientRpc();
		}

		[ClientRpc]
		public void DestroyClientRpc()
		{
			DestroyLocalClient();
		}

		[ServerRpc]
		public void DrawCardServerRpc(ulong playerWhoPulled)
		{
			Type item = AllCards.PullRandomCard();
			int pulledCard = AllCards.GetAllCardsAsList().IndexOf(item);
			DrawCardClientRpc(playerWhoPulled, pulledCard);
		}

		[ClientRpc]
		public void DrawCardClientRpc(ulong playerWhoPulled, int pulledCard)
		{
			isDrawingCard = true;
			playerWhoDrew = StartOfRound.Instance.allPlayerScripts[playerWhoPulled];
			if ((Object)(object)playerWhoDrew == (Object)null)
			{
				PluginLogger.Error("Player is null when drawing card");
			}
			StartDrawingCard(pulledCard);
		}
	}
}
namespace LCTarrotCard.Cards
{
	public static class AllCards
	{
		public static class ProbabilityTable
		{
			public static int TowerCard = 20;

			public static int WheelCard = 20;

			public static int SunCard = 5;

			public static int MoonCard = 5;

			public static int DevilCard = 10;

			public static int HermitCard = 10;

			public static int HighPriestessCard = 2;

			public static int DeathCard = 10;

			public static int HangedManCard = 1;

			public static int FoolCard = 17;
		}

		public static readonly Dictionary<Type, int> AllCardsWeighted = new Dictionary<Type, int>();

		private static int _totalWeight;

		internal static void Init()
		{
			AllCardsWeighted.Add(typeof(TowerCard), ProbabilityTable.TowerCard);
			AllCardsWeighted.Add(typeof(WheelCard), ProbabilityTable.WheelCard);
			AllCardsWeighted.Add(typeof(SunCard), ProbabilityTable.SunCard);
			AllCardsWeighted.Add(typeof(MoonCard), ProbabilityTable.MoonCard);
			AllCardsWeighted.Add(typeof(DevilCard), ProbabilityTable.DevilCard);
			AllCardsWeighted.Add(typeof(HermitCard), ProbabilityTable.HermitCard);
			AllCardsWeighted.Add(typeof(HighPriestessCard), ProbabilityTable.HighPriestessCard);
			AllCardsWeighted.Add(typeof(DeathCard), ProbabilityTable.DeathCard);
			AllCardsWeighted.Add(typeof(HangedManCard), ProbabilityTable.HangedManCard);
			AllCardsWeighted.Add(typeof(FoolCard), ProbabilityTable.FoolCard);
			RecalculateTotalWeight();
		}

		public static void RegisterCard(Type cardType, int weight)
		{
			if (!typeof(Card).IsAssignableFrom(cardType))
			{
				PluginLogger.Warning("Trying to register a non-card type (type : " + cardType.Name + ")");
				return;
			}
			if (AllCardsWeighted.ContainsKey(cardType))
			{
				PluginLogger.Warning("Trying to register a card that is already registered (type : " + cardType.Name + ")");
				return;
			}
			AllCardsWeighted.Add(cardType, weight);
			RecalculateTotalWeight();
		}

		public static List<Type> GetAllCardsAsList()
		{
			return new List<Type>(AllCardsWeighted.Keys);
		}

		private static void RecalculateTotalWeight()
		{
			_totalWeight = 0;
			foreach (int value in AllCardsWeighted.Values)
			{
				_totalWeight += value;
			}
		}

		public static Type PullRandomCard()
		{
			int num = 0;
			int num2 = Random.Range(0, _totalWeight + 1);
			Type type = typeof(object);
			foreach (KeyValuePair<Type, int> item in AllCardsWeighted)
			{
				if (item.Value + num >= num2)
				{
					type = item.Key;
					break;
				}
				num += item.Value;
			}
			PluginLogger.Debug(type.Name);
			if (typeof(Card).IsAssignableFrom(type))
			{
				return type;
			}
			PluginLogger.Warning("Trying to pull a card with a non-card type (type : " + type.Name + ")");
			return typeof(FoolCard);
		}
	}
	public abstract class Card
	{
		protected static readonly AnimationCurve ControlCurve = new AnimationCurve((Keyframe[])(object)new Keyframe[2]
		{
			new Keyframe(0f, 0f, 0f, 0f, 0.5f, 0.5f),
			new Keyframe(1f, 1f, 0f, 0f, 0f, 0f)
		});

		protected readonly AudioSource cardAudio;

		protected readonly GameObject cardPrefab;

		protected Card(GameObject cardPrefab, AudioSource audioSource)
		{
			this.cardPrefab = cardPrefab;
			cardAudio = audioSource;
		}

		public virtual void InitCard()
		{
			Renderer component = cardPrefab.GetComponent<Renderer>();
			Material[] materials = component.materials;
			materials[0] = GetCardMaterial();
			component.materials = materials;
		}

		public abstract Material GetCardMaterial();

		public abstract Material GetCardBurn();

		public abstract void ExecuteEffect(PlayerControllerB playerWhoDrew);

		public virtual IEnumerator CardPullingCoroutine()
		{
			cardAudio.PlayOneShot(Assets.PullCardClips[Random.Range(0, Assets.PullCardClips.Count)]);
			yield return (object)new WaitForSeconds(2.2f);
			Renderer cardRenderer = cardPrefab.GetComponent<Renderer>();
			Material initMat0 = cardRenderer.materials[0];
			Material initMat1 = cardRenderer.materials[1];
			Material initMat2 = cardRenderer.materials[2];
			float delta = 0f;
			while (delta < 0.3f)
			{
				cardRenderer.materials[0].Lerp(initMat0, GetCardBurn(), delta / 0.3f);
				cardRenderer.materials[1].Lerp(initMat1, GetCardBurn(), delta / 0.3f);
				cardRenderer.materials[2].Lerp(initMat2, GetCardBurn(), delta / 0.3f);
				delta += Time.deltaTime;
				yield return null;
			}
			yield return (object)new WaitForSeconds(0.2f);
			Vector3 initScale = cardPrefab.transform.localScale;
			float delta2 = 0f;
			while (delta2 < 0.3f)
			{
				cardPrefab.transform.localScale = initScale * (1f - ControlCurve.Evaluate(delta2 / 0.3f));
				delta2 += Time.deltaTime;
				yield return null;
			}
			cardPrefab.transform.localScale = Vector3.zero;
		}
	}
	public class DeathCard : Card
	{
		public DeathCard(GameObject cardPrefab, AudioSource audioSource)
			: base(cardPrefab, audioSource)
		{
		}

		public override Material GetCardMaterial()
		{
			return Assets.Materials.CardDeathMat;
		}

		public override Material GetCardBurn()
		{
			return Assets.Materials.BurnPurple;
		}

		public override void ExecuteEffect(PlayerControllerB playerWhoDrew)
		{
			int num = Random.Range(0, 4);
			switch (num)
			{
			case 0:
				PluginLogger.Debug("Agroing coilhead or spawning one");
				Networker.Instance.AgroCoilheadOrSpawnServerRpc();
				break;
			case 1:
				PluginLogger.Debug("Pop or spawning jester");
				Networker.Instance.PopOrSpawnJesterServerRpc(30f);
				break;
			default:
				PluginLogger.Debug("Spawning giant or dog");
				Networker.Instance.SpawnGiantOrDogServerRpc(num - 1);
				break;
			}
		}
	}
	public class DevilCard : Card
	{
		public DevilCard(GameObject cardPrefab, AudioSource audioSource)
			: base(cardPrefab, audioSource)
		{
		}

		public override Material GetCardMaterial()
		{
			return Assets.Materials.CardDevilMat;
		}

		public override Material GetCardBurn()
		{
			return Assets.Materials.BurnRed;
		}

		public override void ExecuteEffect(PlayerControllerB playerWhoDrew)
		{
			//IL_0022: 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_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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			int num = Random.Range(0, 4);
			if (!playerWhoDrew.isPlayerDead && playerWhoDrew.isPlayerControlled)
			{
				if (num <= 2)
				{
					Vector3 position = ((Component)playerWhoDrew).transform.position + ((Component)playerWhoDrew.gameplayCamera).transform.forward * 5f;
					Networker.Instance.TeleportRandomEntityServerRpc(position, playerWhoDrew.isInsideFactory);
				}
				else
				{
					((MonoBehaviour)playerWhoDrew).StartCoroutine(WaitAndBlow(playerWhoDrew));
				}
			}
		}

		private static IEnumerator WaitAndBlow(PlayerControllerB player)
		{
			yield return (object)new WaitForSeconds(2.5f);
			Networker.Instance.GhostBreatheServerRpc(((Component)player).transform.position);
		}
	}
	public class FoolCard : Card
	{
		private readonly Material[] allCardMat = (Material[])(object)new Material[9]
		{
			Assets.Materials.CardTowerMat,
			Assets.Materials.CardDeathMat,
			Assets.Materials.CardWheelMat,
			Assets.Materials.CardSunMat,
			Assets.Materials.CardMoonMat,
			Assets.Materials.CardDevilMat,
			Assets.Materials.CardHermitMat,
			Assets.Materials.CardPriestessMat,
			Assets.Materials.CardHangedMat
		};

		private Material cardToMimic;

		public FoolCard(GameObject cardPrefab, AudioSource audioSource)
			: base(cardPrefab, audioSource)
		{
		}

		public override void InitCard()
		{
			cardToMimic = allCardMat[Random.Range(0, allCardMat.Length)];
			base.InitCard();
		}

		public override Material GetCardMaterial()
		{
			return cardToMimic;
		}

		public override Material GetCardBurn()
		{
			return Assets.Materials.BurnPurple;
		}

		public override void ExecuteEffect(PlayerControllerB playerWhoDrew)
		{
		}

		public override IEnumerator CardPullingCoroutine()
		{
			cardAudio.PlayOneShot(Assets.PullCardClips[Random.Range(0, Assets.PullCardClips.Count)]);
			Renderer cardRenderer = cardPrefab.GetComponent<Renderer>();
			yield return (object)new WaitForSeconds(1.8f);
			Material initMat = cardRenderer.materials[0];
			Material initMat3 = cardRenderer.materials[1];
			Material initMat5 = cardRenderer.materials[2];
			cardAudio.PlayOneShot(Assets.FoolCardSound);
			float delta3 = 0f;
			while (delta3 < 0.15f)
			{
				cardRenderer.materials[0].Lerp(initMat, GetCardBurn(), delta3 / 0.3f);
				cardRenderer.materials[1].Lerp(initMat3, GetCardBurn(), delta3 / 0.3f);
				cardRenderer.materials[2].Lerp(initMat5, GetCardBurn(), delta3 / 0.3f);
				delta3 += Time.deltaTime;
				yield return null;
			}
			Material trMat0 = cardRenderer.materials[0];
			Material trMat1 = cardRenderer.materials[1];
			Material trMat2 = cardRenderer.materials[2];
			delta3 = 0f;
			while (delta3 < 0.15f)
			{
				cardRenderer.materials[0].Lerp(trMat0, Assets.Materials.CardFoolMat, delta3 / 0.3f);
				cardRenderer.materials[1].Lerp(trMat1, initMat3, delta3 / 0.3f);
				cardRenderer.materials[2].Lerp(trMat2, initMat5, delta3 / 0.3f);
				delta3 += Time.deltaTime;
				yield return null;
			}
			Material[] materials = (Material[])(object)new Material[3]
			{
				Assets.Materials.CardFoolMat,
				initMat3,
				initMat5
			};
			cardRenderer.materials = materials;
			yield return (object)new WaitForSeconds(0.1f);
			initMat = cardRenderer.materials[0];
			initMat3 = cardRenderer.materials[1];
			initMat5 = cardRenderer.materials[2];
			delta3 = 0f;
			while (delta3 < 0.3f)
			{
				cardRenderer.materials[0].Lerp(initMat, GetCardBurn(), delta3 / 0.3f);
				cardRenderer.materials[1].Lerp(initMat3, GetCardBurn(), delta3 / 0.3f);
				cardRenderer.materials[2].Lerp(initMat5, GetCardBurn(), delta3 / 0.3f);
				delta3 += Time.deltaTime;
				yield return null;
			}
			yield return (object)new WaitForSeconds(0.2f);
			Vector3 initScale = cardPrefab.transform.localScale;
			float delta4 = 0f;
			while (delta4 < 0.3f)
			{
				cardPrefab.transform.localScale = initScale * (1f - Card.ControlCurve.Evaluate(delta4 / 0.3f));
				delta4 += Time.deltaTime;
				yield return null;
			}
			cardPrefab.transform.localScale = Vector3.zero;
		}
	}
	public class HangedManCard : Card
	{
		public HangedManCard(GameObject cardPrefab, AudioSource audioSource)
			: base(cardPrefab, audioSource)
		{
		}

		public override Material GetCardMaterial()
		{
			return Assets.Materials.CardHangedMat;
		}

		public override Material GetCardBurn()
		{
			return Assets.Materials.BurnRed;
		}

		public override void ExecuteEffect(PlayerControllerB playerWhoDrew)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (!playerWhoDrew.isPlayerDead && playerWhoDrew.isPlayerControlled)
			{
				Networker.Instance.KillPlayerServerRpc((int)playerWhoDrew.playerClientId, new Vector3(0f, 1f, 0f), (CauseOfDeath)0);
			}
		}
	}
	public class HermitCard : Card
	{
		public HermitCard(GameObject cardPrefab, AudioSource audioSource)
			: base(cardPrefab, audioSource)
		{
		}

		public override Material GetCardMaterial()
		{
			return Assets.Materials.CardHermitMat;
		}

		public override Material GetCardBurn()
		{
			return Assets.Materials.BurnAqua;
		}

		public override void ExecuteEffect(PlayerControllerB playerWhoDrew)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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)
			if (Random.Range(0, 2) == 0)
			{
				PluginLogger.Debug("Teleporting enemy away");
				Networker.Instance.TeleportEnemyAwayServerRpc();
			}
			else
			{
				PluginLogger.Debug("Teleporting player to random inside node");
				Vector3 position = RoundManager.Instance.insideAINodes[Random.Range(0, RoundManager.Instance.insideAINodes.Length)].transform.position;
				Networker.Instance.TeleportPlayerServerRpc((int)playerWhoDrew.playerClientId, position);
			}
		}
	}
	public class HighPriestessCard : Card
	{
		public HighPriestessCard(GameObject cardPrefab, AudioSource audioSource)
			: base(cardPrefab, audioSource)
		{
		}

		public override Material GetCardMaterial()
		{
			return Assets.Materials.CardPriestessMat;
		}

		public override Material GetCardBurn()
		{
			return Assets.Materials.BurnYellow;
		}

		public override void ExecuteEffect(PlayerControllerB playerWhoDrew)
		{
			int num = -1;
			for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Length; i++)
			{
				PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[i];
				PluginLogger.Debug("Checking player " + val.playerUsername + " isPlayerControlled: " + val.isPlayerControlled + " isPlayerDead: " + val.isPlayerDead);
				if (val.isPlayerDead)
				{
					num = i;
					break;
				}
			}
			if (num != -1)
			{
				PluginLogger.Debug("Reviving player " + StartOfRound.Instance.allPlayerScripts[num].playerUsername);
				Networker.Instance.RevivePlayerServerRpc(num);
			}
			else
			{
				PluginLogger.Debug("No dead player found, allowing extra life");
				Networker.Instance.AllowExtraLifeServerRpc();
			}
		}
	}
	public class MoonCard : Card
	{
		public MoonCard(GameObject cardPrefab, AudioSource audioSource)
			: base(cardPrefab, audioSource)
		{
		}

		public override Material GetCardMaterial()
		{
			return Assets.Materials.CardMoonMat;
		}

		public override Material GetCardBurn()
		{
			return Assets.Materials.BurnWhite;
		}

		public override void ExecuteEffect(PlayerControllerB playerWhoDrew)
		{
			int num = playerWhoDrew.ItemSlots.Count((GrabbableObject item) => Object.op_Implicit((Object)(object)item));
			int num2 = Random.Range(0, 10);
			if (num2 > 6 && num > 2)
			{
				float multiplier = Random.Range(0.1f, 0.9f);
				PluginLogger.Debug("Multiplying inventory value by " + multiplier);
				Networker.Instance.MultiplyInventoryValueServerRpc((int)playerWhoDrew.playerClientId, multiplier);
				return;
			}
			if (num2 == 0)
			{
				float multiplier2 = Random.Range(0.1f, 0.9f);
				PluginLogger.Debug("Multiplying random scrap value by " + multiplier2);
				Networker.Instance.MultiplyRandomScrapValueServerRpc(multiplier2);
				return;
			}
			PluginLogger.Debug("Damaging player to 2 health");
			if (!playerWhoDrew.isPlayerDead && playerWhoDrew.health > 2)
			{
				Networker.Instance.SetPlayerHealthServerRpc((int)playerWhoDrew.playerClientId, 2);
			}
		}
	}
	public class SunCard : Card
	{
		public SunCard(GameObject cardPrefab, AudioSource audioSource)
			: base(cardPrefab, audioSource)
		{
		}

		public override Material GetCardMaterial()
		{
			return Assets.Materials.CardSunMat;
		}

		public override Material GetCardBurn()
		{
			return Assets.Materials.BurnYellow;
		}

		public override void ExecuteEffect(PlayerControllerB playerWhoDrew)
		{
			int num = playerWhoDrew.ItemSlots.Count((GrabbableObject item) => Object.op_Implicit((Object)(object)item));
			int num2 = Random.Range(0, 10);
			if (num2 > 6 && num > 2)
			{
				float multiplier = Random.Range(1.1f, 1.5f);
				PluginLogger.Debug("Multiplying inventory value by " + multiplier);
				Networker.Instance.MultiplyInventoryValueServerRpc((int)playerWhoDrew.playerClientId, multiplier);
				return;
			}
			if (num2 == 0)
			{
				float multiplier2 = Random.Range(1.1f, 1.5f);
				PluginLogger.Debug("Multiplying random scrap value by " + multiplier2);
				Networker.Instance.MultiplyRandomScrapValueServerRpc(multiplier2);
				return;
			}
			PluginLogger.Debug("Healing player to 100 health");
			if (!playerWhoDrew.isPlayerDead && playerWhoDrew.health < 100)
			{
				Networker.Instance.SetPlayerHealthServerRpc((int)playerWhoDrew.playerClientId, 100);
			}
		}
	}
	public class TowerCard : Card
	{
		public TowerCard(GameObject cardPrefab, AudioSource audioSource)
			: base(cardPrefab, audioSource)
		{
		}

		public override Material GetCardMaterial()
		{
			return Assets.Materials.CardTowerMat;
		}

		public override Material GetCardBurn()
		{
			return Assets.Materials.BurnBlue;
		}

		public override void ExecuteEffect(PlayerControllerB playerWhoDrew)
		{
			int num = Random.Range(0, 60);
			if (num == 0)
			{
				return;
			}
			if (num <= 22)
			{
				PluginLogger.Debug("Opening or closing random security doors");
				TerminalAccessibleObject[] array = Object.FindObjectsOfType<TerminalAccessibleObject>();
				foreach (TerminalAccessibleObject val in array)
				{
					if (val.isBigDoor && Random.Range(0, 2) == 0)
					{
						val.SetDoorToggleLocalClient();
					}
				}
			}
			else if (num <= 40)
			{
				PluginLogger.Debug("Opening or closing rng doors");
				Networker.Instance.OpenOrCloseRandomDoorServerRpc((int)playerWhoDrew.playerClientId);
			}
			else if (num <= 55)
			{
				PluginLogger.Debug("Inverting ship door state");
				Networker.Instance.SetShipDoorStateServerRpc(StartOfRound.Instance.hangarDoorsClosed);
			}
			else
			{
				PluginLogger.Debug("Turning off breaker");
				Networker.Instance.BreakerOffServerRpc();
			}
		}
	}
	public class WheelCard : Card
	{
		private bool outcome;

		public WheelCard(GameObject cardPrefab, AudioSource audioSource)
			: base(cardPrefab, audioSource)
		{
		}

		public override void InitCard()
		{
			outcome = Random.Range(0, 2) == 0;
			base.InitCard();
		}

		public override Material GetCardMaterial()
		{
			return Assets.Materials.CardWheelMat;
		}

		public override Material GetCardBurn()
		{
			if (!outcome)
			{
				return Assets.Materials.BurnRed;
			}
			return Assets.Materials.BurnGreen;
		}

		public override void ExecuteEffect(PlayerControllerB playerWhoDrew)
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			int num = Random.Range(0, 2);
			if (outcome)
			{
				switch (num)
				{
				case 0:
					PluginLogger.Debug("Healing by 20 hp");
					if (playerWhoDrew.health >= 80)
					{
						Networker.Instance.SetPlayerHealthServerRpc((int)playerWhoDrew.playerClientId, 100);
					}
					else
					{
						Networker.Instance.SetPlayerHealthServerRpc((int)playerWhoDrew.playerClientId, playerWhoDrew.health + 20);
					}
					break;
				case 1:
					PluginLogger.Debug("Multiplying some scrap value by 1.1");
					Networker.Instance.MultiplyRandomScrapValueServerRpc(1.1f);
					break;
				}
			}
			else
			{
				switch (num)
				{
				case 0:
					PluginLogger.Debug("Damaging by 20 hp");
					Networker.Instance.DamagePlayerServerRpc((int)playerWhoDrew.playerClientId, 20, default(Vector3), (CauseOfDeath)0);
					break;
				case 1:
					PluginLogger.Debug("Multiplying some scrap value by 0.9");
					Networker.Instance.MultiplyRandomScrapValueServerRpc(0.9f);
					break;
				}
			}
		}
	}
}