using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
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 HarmonyLib;
using MenuLib;
using MonoMod.RuntimeDetour;
using Photon.Pun;
using Steamworks;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("MoreChances")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("MoreChances")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("6c82944c-dea5-48b3-b918-69097a25df9d")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace MoreChances;

[BepInPlugin("Turara.Love.BabyJia", "更多机会(MoreChances)", "5.2.0")]
public class DoSomething : BaseUnityPlugin
{
	public static ManualLogSource Debug;

	public static ConfigEntry<bool> GoArena;

	public static ConfigEntry<bool> GoArenaDelete;

	public static ConfigEntry<bool> AllDeadDelete;

	public static ConfigEntry<bool> WhateverNoDelete;

	public static ConfigEntry<bool> ReviveHPEnable;

	public static ConfigEntry<int> ReviveHP;

	public static ConfigEntry<bool> TruckHealEnable;

	public static ConfigEntry<int> TruckHealHP;

	public static ConfigEntry<bool> ChargingStationInfinityPower;

	private REPOButton reMapBtn;

	private REPOButton shopBtn;

	private REPOButton recordBtn;

	private FieldRef<ChargingStation, float> charge = AccessTools.FieldRefAccess<ChargingStation, float>("charge");

	public void Awake()
	{
		//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Expected O, but got Unknown
		//IL_0123: Unknown result type (might be due to invalid IL or missing references)
		//IL_012d: Expected O, but got Unknown
		//IL_0185: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bf: Expected O, but got Unknown
		//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ee: Expected O, but got Unknown
		//IL_0213: Unknown result type (might be due to invalid IL or missing references)
		//IL_021d: Expected O, but got Unknown
		//IL_022d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0248: Unknown result type (might be due to invalid IL or missing references)
		//IL_0263: Unknown result type (might be due to invalid IL or missing references)
		Debug = ((BaseUnityPlugin)this).Logger;
		GoArena = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "是否前往竞技场", false, "默认: 关闭, 团灭后当前进度重新开始，不会前往竞技场");
		GoArenaDelete = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "竞技场(删除存档)", false, "默认: 关闭, 哪怕进入竞技场也不会删除存档");
		AllDeadDelete = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "团灭后(删除存档)", false, "默认: 关闭, 团灭后不会删除存档");
		WhateverNoDelete = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "退出时(删除存档)", false, "默认: 关闭, 无论如何不删除存档");
		ReviveHPEnable = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "生命值调整(复活时)", true, "默认: 开启, 重新开始时的初始生命值增强");
		ReviveHP = ((BaseUnityPlugin)this).Config.Bind<int>("General", "复活的生命值(%)", 100, new ConfigDescription("默认：100%, 即回满血", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
		TruckHealEnable = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "生命值调整(卡车)", true, "默认: 开启, 卡车开车时的恢复生命值增强");
		TruckHealHP = ((BaseUnityPlugin)this).Config.Bind<int>("General", "卡车回复的生命值(%)", 100, new ConfigDescription("默认：100%, 即回满血", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
		ChargingStationInfinityPower = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "无限充电(卡车)", true, "默认：开启，卡车可以无限充电");
		((BaseUnityPlugin)this).Logger.LogInfo((object)"DoSomething Load Success!");
		new Hook((MethodBase)AccessTools.Method(typeof(RunManager), "Awake", (Type[])null, (Type[])null), (Delegate)(Action<Action<RunManager>, RunManager>)delegate(Action<RunManager> orig, RunManager self)
		{
			orig(self);
			if ((Object)(object)((Component)self).gameObject.GetComponent<NoArena>() == (Object)null)
			{
				((Component)self).gameObject.AddComponent<NoArena>();
				((BaseUnityPlugin)this).Logger.LogInfo((object)"NoArena Added!");
			}
		}).Apply();
		reMapBtn = new REPOButton("重新生成地图", (Action)delegate
		{
			if (SemiFunc.RunIsLevel() && SemiFunc.IsMasterClient())
			{
				RunManager.instance.ChangeLevel(false, false, (ChangeLevelType)1);
			}
		});
		shopBtn = new REPOButton("前往商店", (Action)delegate
		{
			if ((SemiFunc.RunIsLevel() || SemiFunc.RunIsShop()) && SemiFunc.IsMasterClient())
			{
				RunManager.instance.ChangeLevel(false, false, (ChangeLevelType)5);
			}
		});
		recordBtn = new REPOButton("前往录音房", (Action)delegate
		{
			if ((SemiFunc.RunIsLevel() || SemiFunc.RunIsShop()) && SemiFunc.IsMasterClient())
			{
				RunManager.instance.ChangeLevel(false, false, (ChangeLevelType)6);
			}
		});
		MenuAPI.AddElementToEscapeMenu((REPOElement)(object)reMapBtn, new Vector2(280f, 250f));
		MenuAPI.AddElementToEscapeMenu((REPOElement)(object)shopBtn, new Vector2(280f, 200f));
		MenuAPI.AddElementToEscapeMenu((REPOElement)(object)recordBtn, new Vector2(280f, 150f));
	}

	public void Update()
	{
		if (Object.op_Implicit((Object)(object)GetMenuButton(reMapBtn)))
		{
			bool flag = SemiFunc.IsMasterClient();
			bool flag2 = SemiFunc.RunIsLevel();
			bool flag3 = flag2 || SemiFunc.RunIsShop();
			bool flag4 = flag3;
			((Behaviour)GetMenuButton(reMapBtn)).enabled = flag && flag2;
			((Behaviour)GetMenuButton(shopBtn)).enabled = flag && flag3;
			((Behaviour)GetMenuButton(recordBtn)).enabled = flag && flag4;
		}
		if (ChargingStationInfinityPower.Value && Object.op_Implicit((Object)(object)ChargingStation.instance) && !SemiFunc.RunIsShop())
		{
			charge.Invoke(ChargingStation.instance) = 1f;
		}
	}

	private MenuButton GetMenuButton(REPOButton rb)
	{
		FieldInfo fieldInfo = AccessTools.Field(typeof(REPOButton), "menuButton");
		object? value = fieldInfo.GetValue(rb);
		return (MenuButton)((value is MenuButton) ? value : null);
	}
}
public class NoArena : MonoBehaviour
{
	private delegate void orig_RunManager_Update(RunManager self);

	private delegate void hook_RunManager_Update(orig_RunManager_Update orig, RunManager self);

	private delegate void orig_RunManager_ChangeLevel(RunManager self, bool _completedLevel, bool _levelFailed, ChangeLevelType _changeLevelType);

	private delegate void hook_RunManager_ChangeLevel(orig_RunManager_ChangeLevel orig, RunManager self, bool _completedLevel, bool _levelFailed, ChangeLevelType _changeLevelType);

	private delegate void orig_PlayerAvatar_ReviveRPC(PlayerAvatar self, bool _revivedByTruck);

	private delegate void hook_PlayerAvatar_ReviveRPC(orig_PlayerAvatar_ReviveRPC orig, PlayerAvatar self, bool _revivedByTruck);

	private delegate void orig_PlayerAvatar_FinalHealRPC(PlayerAvatar self);

	private delegate void hook_PlayerAvatar_FinalHealRPC(orig_PlayerAvatar_FinalHealRPC orig, PlayerAvatar self);

	private delegate IEnumerator orig_PlayerHealth_Fetch(PlayerHealth self);

	private delegate IEnumerator hook_PlayerHealth_Fetch(orig_PlayerHealth_Fetch orig, PlayerHealth self);

	private delegate void orig_DataDirector_SaveDeleteCheck(DataDirector self, bool _leaveGame);

	private delegate void hook_DataDirector_SaveDeleteCheck(orig_DataDirector_SaveDeleteCheck orig, DataDirector self, bool _leaveGame);

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

		private object <>2__current;

		public orig_PlayerHealth_Fetch orig;

		public PlayerHealth self;

		public NoArena <>4__this;

		private int <num>5__1;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (!LevelGenerator.Instance.Generated)
			{
				<>2__current = (object)new WaitForSeconds(0.1f);
				<>1__state = 1;
				return true;
			}
			<>4__this.maxHealth.Invoke(self) = 100 + StatsManager.instance.GetPlayerMaxHealth(SemiFunc.PlayerGetSteamID(<>4__this.playerAvatar.Invoke(self)));
			<num>5__1 = StatsManager.instance.GetPlayerHealth(SemiFunc.PlayerGetSteamID(<>4__this.playerAvatar.Invoke(self)));
			if (<num>5__1 <= 0)
			{
				if (DoSomething.ReviveHPEnable.Value)
				{
					<num>5__1 = Mathf.RoundToInt((float)(<>4__this.maxHealth.Invoke(self) * DoSomething.ReviveHP.Value) / 100f);
				}
				else
				{
					<num>5__1 = 1;
				}
			}
			<>4__this.health.Invoke(self) = Mathf.Clamp(<num>5__1, 0, <>4__this.maxHealth.Invoke(self));
			if (SemiFunc.RunIsArena())
			{
				<>4__this.health.Invoke(self) = <>4__this.maxHealth.Invoke(self);
			}
			StatsManager.instance.SetPlayerHealth(SemiFunc.PlayerGetSteamID(<>4__this.playerAvatar.Invoke(self)), <>4__this.health.Invoke(self), false);
			if (GameManager.Multiplayer())
			{
				<>4__this.photonView.Invoke(self).RPC("UpdateHealthRPC", (RpcTarget)1, new object[3]
				{
					<>4__this.health.Invoke(self),
					<>4__this.maxHealth.Invoke(self),
					true
				});
			}
			<>4__this.healthSet.Invoke(self) = 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();
		}
	}

	private FieldRef<RunManager, bool> restarting = AccessTools.FieldRefAccess<RunManager, bool>("restarting");

	private FieldRef<RunManager, bool> runStarted = AccessTools.FieldRefAccess<RunManager, bool>("runStarted");

	private FieldRef<RunManager, bool> allPlayersDead = AccessTools.FieldRefAccess<RunManager, bool>("allPlayersDead");

	private FieldRef<RunManager, bool> gameOver = AccessTools.FieldRefAccess<RunManager, bool>("gameOver");

	private FieldRef<RunManager, int> saveLevel = AccessTools.FieldRefAccess<RunManager, int>("saveLevel");

	private FieldRef<RunManager, RunManagerPUN> runManagerPUN = AccessTools.FieldRefAccess<RunManager, RunManagerPUN>("runManagerPUN");

	private FieldRef<RunManager, Level> levelPrevious = AccessTools.FieldRefAccess<RunManager, Level>("levelPrevious");

	private FieldRef<RunManager, Level> previousRunLevel = AccessTools.FieldRefAccess<RunManager, Level>("previousRunLevel");

	private FieldRef<RunManager, Level> debugLevel = AccessTools.FieldRefAccess<RunManager, Level>("debugLevel");

	private FieldRef<PlayerAvatar, bool> isDisabled = AccessTools.FieldRefAccess<PlayerAvatar, bool>("isDisabled");

	private FieldRef<PlayerAvatar, bool> finalHeal = AccessTools.FieldRefAccess<PlayerAvatar, bool>("finalHeal");

	private FieldRef<PlayerAvatar, string> playerName = AccessTools.FieldRefAccess<PlayerAvatar, string>("playerName");

	private FieldRef<PlayerHealth, int> maxHealth = AccessTools.FieldRefAccess<PlayerHealth, int>("maxHealth");

	private FieldRef<PlayerHealth, PhotonView> photonView = AccessTools.FieldRefAccess<PlayerHealth, PhotonView>("photonView");

	private FieldRef<PlayerHealth, PlayerAvatar> playerAvatar = AccessTools.FieldRefAccess<PlayerHealth, PlayerAvatar>("playerAvatar");

	private FieldRef<PlayerHealth, int> health = AccessTools.FieldRefAccess<PlayerHealth, int>("health");

	private FieldRef<PlayerHealth, bool> healthSet = AccessTools.FieldRefAccess<PlayerHealth, bool>("healthSet");

	private FieldRef<StatsManager, string> saveFileCurrent = AccessTools.FieldRefAccess<StatsManager, string>("saveFileCurrent");

	private static bool SetupHooked;

	public void Awake()
	{
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0105: Unknown result type (might be due to invalid IL or missing references)
		//IL_0132: Unknown result type (might be due to invalid IL or missing references)
		if (!SetupHooked)
		{
			new Hook((MethodBase)AccessTools.Method(typeof(RunManager), "Update", (Type[])null, (Type[])null), (Delegate)new hook_RunManager_Update(RunManager_Update)).Apply();
			new Hook((MethodBase)AccessTools.Method(typeof(RunManager), "ChangeLevel", (Type[])null, (Type[])null), (Delegate)new hook_RunManager_ChangeLevel(RunManager_ChangeLevel)).Apply();
			DoSomething.Debug.LogInfo((object)"NoArena Hooked RunManager!");
			new Hook((MethodBase)AccessTools.Method(typeof(DataDirector), "SaveDeleteCheck", (Type[])null, (Type[])null), (Delegate)new hook_DataDirector_SaveDeleteCheck(DataDirector_SaveDeleteCheck)).Apply();
			DoSomething.Debug.LogInfo((object)"NoArena Hooked DataDirector!");
			new Hook((MethodBase)AccessTools.Method(typeof(PlayerAvatar), "ReviveRPC", (Type[])null, (Type[])null), (Delegate)new hook_PlayerAvatar_ReviveRPC(PlayerAvatar_ReviveRPC)).Apply();
			new Hook((MethodBase)AccessTools.Method(typeof(PlayerHealth), "Fetch", (Type[])null, (Type[])null), (Delegate)new hook_PlayerHealth_Fetch(PlayerAvatar_Fetch)).Apply();
			new Hook((MethodBase)AccessTools.Method(typeof(PlayerAvatar), "FinalHealRPC", (Type[])null, (Type[])null), (Delegate)new hook_PlayerAvatar_FinalHealRPC(PlayerAvatar_FinalHealRPC)).Apply();
			SetupHooked = true;
		}
	}

	private void PlayerAvatar_FinalHealRPC(orig_PlayerAvatar_FinalHealRPC orig, PlayerAvatar self)
	{
		//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0104: Unknown result type (might be due to invalid IL or missing references)
		if (finalHeal.Invoke(self))
		{
			return;
		}
		if (self.photonView.IsMine)
		{
			self.playerHealth.EyeMaterialOverride((EyeOverrideState)2, 2f, 1);
			TruckScreenText.instance.MessageSendCustom("", playerName.Invoke(self) + " {arrowright}{truck}{check}\n {point}{shades}{pointright}<b><color=#00FF00>+25</color></b>{heart}", 0);
			if (DoSomething.TruckHealEnable.Value)
			{
				self.playerHealth.Heal(maxHealth.Invoke(self.playerHealth) * DoSomething.TruckHealHP.Value / 100, true);
			}
			else
			{
				self.playerHealth.Heal(25, true);
			}
		}
		TruckHealer.instance.Heal(self);
		self.truckReturn.Play(self.PlayerVisionTarget.VisionTransform.position, 1f, 1f, 1f, 1f);
		self.truckReturnGlobal.Play(self.PlayerVisionTarget.VisionTransform.position, 1f, 1f, 1f, 1f);
		((Component)self.playerAvatarVisuals.effectGetIntoTruck).gameObject.SetActive(true);
		finalHeal.Invoke(self) = true;
	}

	[IteratorStateMachine(typeof(<PlayerAvatar_Fetch>d__33))]
	private IEnumerator PlayerAvatar_Fetch(orig_PlayerHealth_Fetch orig, PlayerHealth self)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <PlayerAvatar_Fetch>d__33(0)
		{
			<>4__this = this,
			orig = orig,
			self = self
		};
	}

	private void PlayerAvatar_ReviveRPC(orig_PlayerAvatar_ReviveRPC orig, PlayerAvatar self, bool _revivedByTruck)
	{
		orig(self, _revivedByTruck);
		HealPlayer(self);
	}

	private void HealPlayer(PlayerAvatar self)
	{
		if (self.photonView.IsMine && DoSomething.ReviveHPEnable.Value)
		{
			int num = Mathf.RoundToInt((float)(maxHealth.Invoke(self.playerHealth) * DoSomething.ReviveHP.Value) / 100f);
			self.playerHealth.HealOther(num, true);
			DoSomething.Debug.LogInfo((object)$"HealPlayer Called. heal +{num}hp");
		}
	}

	private void DataDirector_SaveDeleteCheck(orig_DataDirector_SaveDeleteCheck orig, DataDirector self, bool _leaveGame)
	{
		if (SemiFunc.IsMasterClientOrSingleplayer() && !((Object)(object)levelPrevious.Invoke(RunManager.instance) == (Object)(object)RunManager.instance.levelTutorial) && !((Object)(object)levelPrevious.Invoke(RunManager.instance) == (Object)(object)RunManager.instance.levelLobbyMenu) && !((Object)(object)levelPrevious.Invoke(RunManager.instance) == (Object)(object)RunManager.instance.levelMainMenu) && !((Object)(object)levelPrevious.Invoke(RunManager.instance) == (Object)(object)RunManager.instance.levelRecording))
		{
			bool flag = false;
			if (SemiFunc.RunIsArena())
			{
				flag = DoSomething.GoArenaDelete.Value;
			}
			else if (allPlayersDead.Invoke(RunManager.instance) && (Object)(object)levelPrevious.Invoke(RunManager.instance) != (Object)(object)RunManager.instance.levelMainMenu && (Object)(object)levelPrevious.Invoke(RunManager.instance) != (Object)(object)RunManager.instance.levelLobbyMenu && (Object)(object)levelPrevious.Invoke(RunManager.instance) != (Object)(object)RunManager.instance.levelTutorial && (Object)(object)levelPrevious.Invoke(RunManager.instance) != (Object)(object)RunManager.instance.levelLobby && (Object)(object)levelPrevious.Invoke(RunManager.instance) != (Object)(object)RunManager.instance.levelShop && (Object)(object)levelPrevious.Invoke(RunManager.instance) != (Object)(object)RunManager.instance.levelRecording)
			{
				flag = DoSomething.AllDeadDelete.Value;
			}
			else if (_leaveGame && RunManager.instance.levelsCompleted == 0)
			{
				flag = DoSomething.WhateverNoDelete.Value;
			}
			if (flag)
			{
				SemiFunc.SaveFileDelete(saveFileCurrent.Invoke(StatsManager.instance));
			}
		}
	}

	private void RunManager_ChangeLevel(orig_RunManager_ChangeLevel orig, RunManager self, bool _completedLevel, bool _levelFailed, ChangeLevelType _changeLevelType)
	{
		//IL_0103: Unknown result type (might be due to invalid IL or missing references)
		//IL_0106: Invalid comparison between Unknown and I4
		//IL_011c: Unknown result type (might be due to invalid IL or missing references)
		//IL_011f: Invalid comparison between Unknown and I4
		//IL_013a: Unknown result type (might be due to invalid IL or missing references)
		//IL_013d: Invalid comparison between Unknown and I4
		//IL_0158: Unknown result type (might be due to invalid IL or missing references)
		//IL_015b: Invalid comparison between Unknown and I4
		//IL_0176: Unknown result type (might be due to invalid IL or missing references)
		//IL_0179: Invalid comparison between Unknown and I4
		//IL_0194: Unknown result type (might be due to invalid IL or missing references)
		//IL_0197: Invalid comparison between Unknown and I4
		//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_03d6: Invalid comparison between Unknown and I4
		if ((!SemiFunc.MenuLevel() && !SemiFunc.IsMasterClientOrSingleplayer()) || restarting.Invoke(self))
		{
			return;
		}
		gameOver.Invoke(self) = false;
		if (_levelFailed && (Object)(object)self.levelCurrent != (Object)(object)self.levelLobby && (Object)(object)self.levelCurrent != (Object)(object)self.levelShop)
		{
			if ((Object)(object)self.levelCurrent == (Object)(object)self.levelArena)
			{
				if (DoSomething.GoArenaDelete.Value)
				{
					self.ResetProgress();
				}
				if (SemiFunc.IsMultiplayer())
				{
					self.levelCurrent = self.levelLobbyMenu;
				}
				else
				{
					self.SetRunLevel();
				}
				gameOver.Invoke(self) = true;
			}
			else
			{
				self.levelCurrent = self.levelArena;
			}
		}
		if (!gameOver.Invoke(self) && (Object)(object)self.levelCurrent != (Object)(object)self.levelArena)
		{
			if ((int)_changeLevelType == 1)
			{
				self.SetRunLevel();
			}
			else if ((int)_changeLevelType == 3)
			{
				self.levelCurrent = self.levelLobbyMenu;
			}
			else if ((int)_changeLevelType == 4)
			{
				self.levelCurrent = self.levelMainMenu;
			}
			else if ((int)_changeLevelType == 2)
			{
				self.levelCurrent = self.levelTutorial;
			}
			else if ((int)_changeLevelType == 6)
			{
				self.levelCurrent = self.levelRecording;
			}
			else if ((int)_changeLevelType == 5)
			{
				self.levelCurrent = self.levelShop;
			}
			else if ((Object)(object)self.levelCurrent == (Object)(object)self.levelMainMenu || (Object)(object)self.levelCurrent == (Object)(object)self.levelLobbyMenu)
			{
				self.levelCurrent = self.levelLobby;
			}
			else if (_completedLevel && (Object)(object)self.levelCurrent != (Object)(object)self.levelLobby && (Object)(object)self.levelCurrent != (Object)(object)self.levelShop)
			{
				previousRunLevel.Invoke(self) = self.levelCurrent;
				self.levelsCompleted++;
				SemiFunc.StatSetRunLevel(self.levelsCompleted);
				SemiFunc.LevelSuccessful();
				self.levelCurrent = self.levelShop;
			}
			else if ((Object)(object)self.levelCurrent == (Object)(object)self.levelLobby)
			{
				self.SetRunLevel();
			}
			else if ((Object)(object)self.levelCurrent == (Object)(object)self.levelShop)
			{
				self.levelCurrent = self.levelLobby;
			}
		}
		if (Object.op_Implicit((Object)(object)debugLevel.Invoke(self)) && (Object)(object)self.levelCurrent != (Object)(object)self.levelMainMenu && (Object)(object)self.levelCurrent != (Object)(object)self.levelLobbyMenu)
		{
			self.levelCurrent = debugLevel.Invoke(self);
		}
		if (GameManager.Multiplayer())
		{
			((Component)runManagerPUN.Invoke(self)).GetComponent<PhotonView>().RPC("UpdateLevelRPC", (RpcTarget)4, new object[3]
			{
				((Object)self.levelCurrent).name,
				self.levelsCompleted,
				gameOver.Invoke(self)
			});
		}
		Debug.Log((object)("Changed level to: " + ((Object)self.levelCurrent).name));
		if ((Object)(object)self.levelCurrent == (Object)(object)self.levelShop)
		{
			saveLevel.Invoke(self) = 1;
		}
		else
		{
			saveLevel.Invoke(self) = 0;
		}
		SemiFunc.StatSetSaveLevel(saveLevel.Invoke(self));
		self.RestartScene();
		if ((int)_changeLevelType != 2)
		{
			SemiFunc.OnSceneSwitch(gameOver.Invoke(self), false);
		}
	}

	private void RunManager_Update(orig_RunManager_Update orig, RunManager self)
	{
		//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Invalid comparison between Unknown and I4
		if (GameManager.Multiplayer() && !PhotonNetwork.IsMasterClient)
		{
			return;
		}
		if (LevelGenerator.Instance.Generated && !SteamClient.IsValid && !((Behaviour)SteamManager.instance).enabled)
		{
			Debug.LogError((object)"Steam not initialized. Quitting game.");
			Application.Quit();
		}
		if (restarting.Invoke(self))
		{
			self.RestartScene();
		}
		if (restarting.Invoke(self) || !runStarted.Invoke(self) || GameDirector.instance.PlayerList.Count <= 0 || SemiFunc.RunIsArena() || (int)GameDirector.instance.currentState != 2 || !GameDirector.instance.PlayerList.All((PlayerAvatar x) => isDisabled.Invoke(x)))
		{
			return;
		}
		allPlayersDead.Invoke(self) = true;
		if (Object.op_Implicit((Object)(object)SpectateCamera.instance) && SpectateCamera.instance.CheckState((State)1))
		{
			if (DoSomething.GoArena.Value)
			{
				self.ChangeLevel(false, true, (ChangeLevelType)0);
			}
			else
			{
				self.ChangeLevel(false, false, (ChangeLevelType)1);
			}
		}
	}
}