using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
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 System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HG;
using HG.Reflection;
using IL.RoR2;
using LeTai.Asset.TranslucentImage;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using On.RoR2;
using On.RoR2.UI;
using R2API;
using RiskOfOptions;
using RiskOfOptions.OptionConfigs;
using RiskOfOptions.Options;
using RiskOfRoutes;
using RiskOfRoutes.StageModifiers;
using RiskOfRoutes.StageModifiers.CombatModifiers;
using RiskOfRoutes.StageModifiers.OtherModifiers;
using RiskOfRoutes.StageModifiers.SceneModifiers;
using RoR2;
using RoR2.Artifacts;
using RoR2.CharacterAI;
using RoR2.ExpansionManagement;
using RoR2.Navigation;
using RoR2.UI;
using SamplePlugin;
using SamplePlugin.StageModifiers;
using SamplePlugin.StageModifiers.BossRewardModifiers;
using SamplePlugin.StageModifiers.CombatModifiers;
using SamplePlugin.StageModifiers.OtherModifiers;
using SamplePlugin.StageModifiers.SceneModifiers;
using TMPro;
using Unity;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: OptIn]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyInformationalVersion("1.0.0+1027ebc23d4b579fb2e8fe94723bf2ece01c5281")]
[assembly: AssemblyProduct("RiskOfRoutes")]
[assembly: AssemblyTitle("RiskOfRoutes")]
[assembly: AssemblyCompany("RiskOfRoutes")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
public class RouteMap
{
	public class RouteNode
	{
		public RoutePortalType portalType;

		public int x;

		public int y;

		public bool visited;

		public bool shopVisited;

		public bool goldshoresVisited;

		public bool voidFieldsVisited;

		public RouteNode left;

		public RouteNode front;

		public RouteNode right;

		public RouteNode portalNode;

		public RouteNode(int x, int y)
		{
			portalType = RoutePortalType.None;
			this.x = x;
			this.y = y;
		}

		public List<RouteNode> GetPaths(bool usePortalNode = false)
		{
			List<RouteNode> list = new List<RouteNode>();
			if (left != null)
			{
				list.Add(left);
			}
			if (front != null)
			{
				list.Add(front);
			}
			if (right != null)
			{
				list.Add(right);
			}
			if (portalNode != null && usePortalNode)
			{
				list.Add(portalNode);
			}
			return list;
		}

		public override string ToString()
		{
			return $"Node:{x}.{y} with {GetPaths().Count} paths";
		}
	}

	public int width;

	public int height;

	public int startingRoutes = 3;

	public bool isMoonVisited = false;

	public RouteNode[,] mapGrid;

	public RouteNode root;

	public bool isDirty = false;

	public RouteMap(Xoroshiro128Plus rng)
	{
		width = global::RiskOfRoutes.RiskOfRoutes.routeMapWidth.Value;
		height = 5;
		mapGrid = new RouteNode[width + 1, height];
		mapGrid[0, 0] = new RouteNode(0, 0);
		root = mapGrid[0, 0];
		root.visited = true;
		root.portalType = RoutePortalType.Starting;
		for (int i = 0; i < width; i++)
		{
			for (int j = 1; j < height; j++)
			{
				mapGrid[i, j] = new RouteNode(i, j);
			}
		}
		List<RouteNode> list = SetupPaths(rng);
		list.Sort((RouteNode a, RouteNode b) => a.x.CompareTo(b.x));
		if (list.Count >= 1)
		{
			root.left = list[0];
		}
		if (list.Count >= 2)
		{
			root.front = list[1];
		}
		if (list.Count >= 3)
		{
			root.right = list[2];
		}
		SetupRewards(rng);
		isDirty = true;
	}

	public void SetupRewards(Xoroshiro128Plus rng)
	{
		WeightedSelection<RoutePortalType> val = new WeightedSelection<RoutePortalType>(8);
		val.AddChoice(RoutePortalType.Heal, 1f);
		val.AddChoice(RoutePortalType.Combat, 1f);
		val.AddChoice(RoutePortalType.Utility, 1f);
		val.AddChoice(RoutePortalType.DroneType, 1f);
		WeightedSelection<RoutePortalType> val2 = new WeightedSelection<RoutePortalType>(8);
		val2.AddChoice(RoutePortalType.Heal, 1f);
		val2.AddChoice(RoutePortalType.Combat, 1f);
		val2.AddChoice(RoutePortalType.Utility, 1f);
		val2.AddChoice(RoutePortalType.DroneType, 1f);
		val2.AddChoice(RoutePortalType.ChefType, 0.8f);
		val2.AddChoice(RoutePortalType.Rare, 0.8f);
		for (int i = 0; i < width; i++)
		{
			if (mapGrid[i, 1].portalType != 0)
			{
				mapGrid[i, 1].portalType = val.Evaluate(rng.nextNormalizedFloat);
			}
			if (mapGrid[i, 3].portalType != 0)
			{
				mapGrid[i, 3].portalType = val2.Evaluate(rng.nextNormalizedFloat);
			}
			if (mapGrid[i, 2].portalType != 0)
			{
				mapGrid[i, 2].portalType = val2.Evaluate(rng.nextNormalizedFloat);
			}
			if (mapGrid[i, 4].portalType != 0)
			{
				mapGrid[i, 4].portalType = RoutePortalType.ChefType;
			}
		}
		HashSet<Vector2> memory = new HashSet<Vector2>();
		List<RouteNode> paths = root.GetPaths();
		CheckNodeCorrect(root, rng, memory);
		foreach (RouteNode item in paths)
		{
			CheckNodeCorrect(item, rng, memory);
		}
	}

	private void CheckNodeCorrect(RouteNode node, Xoroshiro128Plus rng, HashSet<Vector2> memory)
	{
		//IL_0017: 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)
		Vector2 item = default(Vector2);
		((Vector2)(ref item))..ctor((float)node.x, (float)node.y);
		if (memory.Contains(item))
		{
			return;
		}
		memory.Add(item);
		RoutePortalType routePortalType = RoutePortalType.None;
		List<RouteNode> paths = node.GetPaths();
		if (paths.Count == 0)
		{
			return;
		}
		routePortalType = node.portalType;
		foreach (RouteNode item2 in paths)
		{
			if (item2.portalType == node.portalType)
			{
				item2.portalType = RollPortalType(rng, node.portalType);
			}
		}
		if (paths.Count > 1)
		{
			if (paths.Count == 2)
			{
				if (paths[0].portalType == paths[1].portalType)
				{
					paths[1].portalType = RollPortalType(rng, paths[0].portalType, routePortalType);
				}
			}
			else if (paths.Count == 3)
			{
				if (paths[0].portalType == paths[1].portalType)
				{
					paths[1].portalType = RollPortalType(rng, paths[0].portalType, routePortalType);
				}
				if (paths[2].portalType == paths[0].portalType || paths[2].portalType == paths[1].portalType)
				{
					paths[2].portalType = RollPortalType(rng, paths[0].portalType, paths[1].portalType, routePortalType);
				}
			}
		}
		foreach (RouteNode item3 in paths)
		{
			CheckNodeCorrect(item3, rng, memory);
		}
	}

	private RoutePortalType RollPortalType(Xoroshiro128Plus rng, params RoutePortalType[] skipTypes)
	{
		WeightedSelection<RoutePortalType> val = new WeightedSelection<RoutePortalType>(8);
		RoutePortalType[] array = new RoutePortalType[6]
		{
			RoutePortalType.Combat,
			RoutePortalType.Heal,
			RoutePortalType.Utility,
			RoutePortalType.DroneType,
			RoutePortalType.Rare,
			RoutePortalType.ChefType
		};
		RoutePortalType[] array2 = array;
		foreach (RoutePortalType routePortalType in array2)
		{
			if (!skipTypes.Contains(routePortalType))
			{
				if (routePortalType == RoutePortalType.Rare || routePortalType == RoutePortalType.ChefType)
				{
					val.AddChoice(routePortalType, 0.8f);
				}
				else
				{
					val.AddChoice(routePortalType, 1f);
				}
			}
		}
		return val.Evaluate(rng.nextNormalizedFloat);
	}

	public List<RouteNode> SetupPaths(Xoroshiro128Plus rng)
	{
		List<RouteNode> list = new List<RouteNode>();
		List<int> list2 = new List<int>();
		for (int i = 0; i < width; i++)
		{
			list2.Add(i);
		}
		for (int j = 0; j < startingRoutes; j++)
		{
			if (list2.Count == 0)
			{
				break;
			}
			int num = rng.NextElementUniform<int>(list2);
			list2.Remove(num);
			RouteNode routeNode = mapGrid[num, 1];
			if (routeNode != null)
			{
				routeNode.portalType = RoutePortalType.Rare;
				CreateRoute(routeNode, routeNode.x, routeNode.y, rng);
				list.Add(routeNode);
			}
		}
		return list;
	}

	public void CreateRoute(RouteNode curr, int x, int y, Xoroshiro128Plus rng)
	{
		if (y >= height - 1)
		{
			return;
		}
		List<RouteNode> list = new List<RouteNode>();
		for (int i = 0; i < 3; i++)
		{
			int num = x - 1 + i;
			int num2 = y + 1;
			if (num >= 0 && num <= width - 1 && (i != 0 || mapGrid[num, y].right == null) && (i != 2 || mapGrid[num, y].left == null))
			{
				list.Add(mapGrid[x - 1 + i, y + 1]);
			}
		}
		if (list.Count != 0)
		{
			RouteNode routeNode = rng.NextElementUniform<RouteNode>(list);
			if (list.Count > 1 && rng.nextNormalizedFloat < 0.2f)
			{
				list.Remove(routeNode);
				RouteNode routeNode2 = rng.NextElementUniform<RouteNode>(list);
				routeNode2.portalType = RoutePortalType.Rare;
				Connect(curr, routeNode2);
				CreateRoute(routeNode2, routeNode2.x, routeNode2.y, rng);
			}
			routeNode.portalType = RoutePortalType.Rare;
			Connect(curr, routeNode);
			CreateRoute(routeNode, routeNode.x, routeNode.y, rng);
		}
	}

	public RouteNode CreateColossusNode(RouteNode current, bool currentLayer = false)
	{
		if (current.y == height - 1 || current.y > 3)
		{
			return null;
		}
		int num = (currentLayer ? current.y : (current.y + 1));
		Log.Info("Creating colossus node");
		isDirty = true;
		RouteNode routeNode = null;
		for (int i = 0; i < width + 1; i++)
		{
			if (mapGrid[i, num] != null && (mapGrid[i, num].portalType == RoutePortalType.Colossus || mapGrid[i, num].portalType == RoutePortalType.FalseSon))
			{
				routeNode = mapGrid[i, num];
				Log.Info("Floor already has colossus node");
				return routeNode;
			}
		}
		Log.Info("Has no colossus nodes");
		for (int j = 0; j < width; j++)
		{
			int[] array = new int[2]
			{
				current.x + j,
				current.x - j
			};
			int[] array2 = array;
			foreach (int num2 in array2)
			{
				if (num2 >= 0 && num2 < width && mapGrid[num2, num].portalType == RoutePortalType.None)
				{
					routeNode = mapGrid[num2, num];
					break;
				}
			}
			if (routeNode != null)
			{
				break;
			}
		}
		if (routeNode == null)
		{
			Log.Warning("No place for colossus node, placing on extra");
			mapGrid[width, num] = new RouteNode(width, num);
			routeNode = mapGrid[width, num];
		}
		if (routeNode != null)
		{
			routeNode.portalType = ((num != 3) ? RoutePortalType.Colossus : RoutePortalType.FalseSon);
			current.portalNode = routeNode;
			if (routeNode.portalType == RoutePortalType.FalseSon)
			{
				ConnectToRandomNode(routeNode, thisLayer: true);
			}
			else
			{
				ConnectToRandomNode(routeNode);
			}
			return routeNode;
		}
		Log.Error("Still null");
		return null;
	}

	public RouteNode CreateHardwareNode(RouteNode current)
	{
		int num = current.y + 1;
		Log.Info("Creating hardware node");
		isDirty = true;
		RouteNode routeNode = null;
		for (int i = 0; i < width + 1; i++)
		{
			if (mapGrid[i, num] != null && (mapGrid[i, num].portalType == RoutePortalType.Hardware || mapGrid[i, num].portalType == RoutePortalType.SolusWing))
			{
				routeNode = mapGrid[i, num];
				Log.Info("Floor already has hardware node");
				return routeNode;
			}
		}
		Log.Info("Has no hardware nodes");
		for (int j = 0; j < width; j++)
		{
			int[] array = new int[2]
			{
				current.x + j,
				current.x - j
			};
			int[] array2 = array;
			foreach (int num2 in array2)
			{
				if (num2 >= 0 && num2 < width && mapGrid[num2, num].portalType == RoutePortalType.None)
				{
					routeNode = mapGrid[num2, num];
					break;
				}
			}
			if (routeNode != null)
			{
				break;
			}
		}
		if (routeNode == null)
		{
			Log.Warning("No place for hardware node, placing on extra");
			mapGrid[width, num] = new RouteNode(width, num);
			routeNode = mapGrid[width, num];
		}
		if (routeNode != null)
		{
			routeNode.portalType = ((num != 4) ? RoutePortalType.Hardware : RoutePortalType.SolusWing);
			current.portalNode = routeNode;
			return routeNode;
		}
		Log.Error("Still null");
		return null;
	}

	private void ConnectToRandomNode(RouteNode node, bool thisLayer = false)
	{
		int y = node.y;
		int num = (thisLayer ? y : (y + 1));
		List<RouteNode> list = new List<RouteNode>();
		for (int i = 0; i < width; i++)
		{
			RouteNode routeNode = mapGrid[i, num];
			if (routeNode != null && routeNode.portalType != 0 && routeNode != node)
			{
				list.Add(routeNode);
			}
		}
		if (list.Count > 0)
		{
			node.front = Run.instance.stageRng.NextElementUniform<RouteNode>(list);
		}
		else
		{
			Log.Warning("ConnectToRandomNode: No valid target nodes to connect");
		}
	}

	private void Connect(RouteNode curr, RouteNode next)
	{
		if (curr.x - next.x == -1)
		{
			curr.right = next;
		}
		else if (curr.x - next.x == 0)
		{
			curr.front = next;
		}
		else
		{
			curr.left = next;
		}
	}

	public RouteNode GetStartingNode()
	{
		return mapGrid[0, 0];
	}
}
public enum RoutePortalType
{
	None,
	Rare,
	ItemType,
	DroneType,
	ChefType,
	Colossus,
	Hardware,
	SolusWing,
	Goldshores,
	Shop,
	Arena,
	FalseSon,
	Starting,
	Combat,
	Heal,
	Utility
}
public enum ModifierTier
{
	Tier1 = 1,
	Tier2,
	Tier3
}
public enum ModifierRarity
{
	Common,
	Rare
}
namespace SamplePlugin
{
	public class CommandHelper : MonoBehaviour
	{
		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCGetNextStagesScenes(ConCommandArgs args)
		{
			Log.Info("Next stages available:");
			foreach (SceneDef nextStagesScenes in SceneHelper.GetNextStagesScenesList())
			{
				Log.Info(nextStagesScenes.cachedName);
			}
			Log.Info(Run.instance.nextStageScene.destinationsGroup);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCGetBannedStage(ConCommandArgs args)
		{
			Log.Info("Banned on stage: ");
			foreach (string item in StageModifierDirector.instance.bannedModifiersStage)
			{
				Log.Info("\t" + item);
			}
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCGetBannedRun(ConCommandArgs args)
		{
			Log.Info("Banned in run: ");
			foreach (string item in StageModifierDirector.instance.bannedModifiersRun)
			{
				Log.Info("\t" + item);
			}
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCGetAvailablePrinters(ConCommandArgs args)
		{
			Log.Info("Printer items: ");
			Log.Info("\tUtility pool: ");
			foreach (string item in StageModifierCatalog.utilityPool)
			{
				Log.Info("\t\t" + item);
			}
			Log.Info("Heal pool: ");
			foreach (string item2 in StageModifierCatalog.healPool)
			{
				Log.Info("\t\t" + item2);
			}
			Log.Info("Damage pool: ");
			foreach (string item3 in StageModifierCatalog.combatPool)
			{
				Log.Info("\t\t" + item3);
			}
			Log.Info("Food-related pool: ");
			foreach (string item4 in StageModifierCatalog.chefPool)
			{
				Log.Info("\t\t" + item4);
			}
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCGetAvailableEnemyItems(ConCommandArgs args)
		{
			Log.Info("Enemy items: ");
			foreach (string item in StageModifierCatalog.generalNegativePool)
			{
				if (item.EndsWith("_EnemyItem"))
				{
					Log.Info("\t" + item);
				}
			}
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCGetAvailableLunarItems(ConCommandArgs args)
		{
			Log.Info("Lunar items: ");
			foreach (string item in StageModifierCatalog.generalNegativePool)
			{
				if (item.EndsWith("_LunarItem"))
				{
					Log.Info("\t" + item);
				}
			}
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCGetAvailableArtifacts(ConCommandArgs args)
		{
			Log.Info("Artifacts available: ");
			foreach (string item in StageModifierCatalog.generalNegativePool.Where((string def) => StageModifierCatalog.FindModifier(def).isArtifact))
			{
				Log.Info("\t" + item);
			}
			foreach (string item2 in StageModifierCatalog.rarePool.Where((string def) => StageModifierCatalog.FindModifier(def).isArtifact))
			{
				Log.Info("\t" + item2);
			}
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCGetAllArtifactDefs(ConCommandArgs args)
		{
			Log.Info("Artifacts defs: ");
			ArtifactDef[] artifactDefs = ArtifactCatalog.artifactDefs;
			foreach (ArtifactDef val in artifactDefs)
			{
				Log.Info("\t" + val.cachedName + " - " + val.nameToken);
			}
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCReinit(ConCommandArgs args)
		{
			StageModifierCatalog.Init(AssetManager.bundle);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCGetNextGreenStage(ConCommandArgs args)
		{
			Log.Info($"Modul:{Stage.instance.sceneDef.stageOrder}");
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCGetDccs(ConCommandArgs args)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			Log.Info("Available enemies");
			WeightedSelection<DirectorCard> monsterSelection = ClassicStageInfo.instance.monsterSelection;
			if (monsterSelection != null)
			{
				for (int i = 0; i < monsterSelection.Count; i++)
				{
					DirectorCard value = monsterSelection.GetChoice(i).value;
					Log.Info($"DirectorCard {((Object)value.spawnCard).name}, cost: {value.cost}, weight: {value.selectionWeight}");
				}
			}
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCGetCurrentNode(ConCommandArgs args)
		{
			List<RouteNodeSync> routeNodesSynced = StageModifierDirector.instance.routeNodesSynced;
			if (routeNodesSynced.Count == 0)
			{
				Log.Error("none");
			}
			foreach (RouteNodeSync item in routeNodesSynced)
			{
				Log.Info($"{item.x}.{item.y}:{item.portalType}-{item.visited}");
			}
			RouteMap.RouteNode currentNode = StageModifierDirector.instance.currentNode;
			Log.Info($"Current node is {currentNode.x},{currentNode.y} with {currentNode.GetPaths().Count} children, visited {currentNode.visited}");
			Log.Info("\tNext scene:" + Run.instance.nextStageScene.cachedName);
			Log.Info("\tCurr scene:" + Stage.instance.sceneDef.cachedName);
			Log.Info($"\tLoop clear count:{Run.instance.loopClearCount}");
			Log.Info($"Child node: {currentNode.GetPaths()[0].x}.{currentNode.GetPaths()[0].y}: {currentNode.GetPaths()[0].portalType}");
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCGetElitesAvailable(ConCommandArgs args)
		{
			FieldInfo field = typeof(CombatDirector).GetField("eliteTiers", BindingFlags.Static | BindingFlags.NonPublic);
			if (!(field != null))
			{
				return;
			}
			EliteTierDef[] array = (EliteTierDef[])field.GetValue(null);
			Log.Info($"Tier count{array.Length}");
			for (int i = 0; i < array.Length; i++)
			{
				Log.Info($"Tier{i + 1}: {array[i].availableDefs.Count}");
				foreach (EliteDef availableDef in array[i].availableDefs)
				{
					if ((Object)(object)availableDef != (Object)null)
					{
						Log.Info("\t " + ((Object)availableDef).name);
					}
				}
			}
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCGetItemDefs(ConCommandArgs args)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			Log.Info("Enemies can have");
			foreach (ItemDef item in ((IEnumerable<ItemDef>)(object)ItemCatalog.allItemDefs).Where((ItemDef def) => def.DoesNotContainTag((ItemTag)4)))
			{
				Log.Info($"\t{((Object)item).name}, {item.requiredExpansion}");
			}
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCSetPunish(ConCommandArgs args)
		{
			if (NetworkServer.active)
			{
				int value = ((ConCommandArgs)(ref args)).TryGetArgInt(0).Value;
				StageModifierDirector.instance.commandAddedStack = value;
				Log.Info($"Set additional punish to {value}");
			}
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCItemTags(ConCommandArgs args)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Invalid comparison between Unknown and I4
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Invalid comparison between Unknown and I4
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Invalid comparison between Unknown and I4
			Log.Info("Items with damage tag");
			Enumerator<ItemDef> enumerator = ItemCatalog.allItemDefs.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					ItemDef current = enumerator.Current;
					if (current.tags.Contains((ItemTag)1) && ((int)current.tier == 0 || (int)current.tier == 1))
					{
						Log.Info("\t" + ((Object)current).name + ":" + Language.GetString(current.nameToken));
					}
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
			Log.Info("Items with healing tag");
			Enumerator<ItemDef> enumerator2 = ItemCatalog.allItemDefs.GetEnumerator();
			try
			{
				while (enumerator2.MoveNext())
				{
					ItemDef current2 = enumerator2.Current;
					if (current2.tags.Contains((ItemTag)2) && ((int)current2.tier == 0 || (int)current2.tier == 1))
					{
						Log.Info("\t" + ((Object)current2).name + ":" + Language.GetString(current2.nameToken));
					}
				}
			}
			finally
			{
				((IDisposable)enumerator2).Dispose();
			}
			Log.Info("Items with utility tag");
			Enumerator<ItemDef> enumerator3 = ItemCatalog.allItemDefs.GetEnumerator();
			try
			{
				while (enumerator3.MoveNext())
				{
					ItemDef current3 = enumerator3.Current;
					if (current3.tags.Contains((ItemTag)3) && ((int)current3.tier == 0 || (int)current3.tier == 1))
					{
						Log.Info("\t" + ((Object)current3).name + ":" + Language.GetString(current3.nameToken));
					}
				}
			}
			finally
			{
				((IDisposable)enumerator3).Dispose();
			}
			Log.Info("Items with food-related tag");
			Enumerator<ItemDef> enumerator4 = ItemCatalog.allItemDefs.GetEnumerator();
			try
			{
				while (enumerator4.MoveNext())
				{
					ItemDef current4 = enumerator4.Current;
					if (current4.tags.Contains((ItemTag)28) && ((int)current4.tier == 0 || (int)current4.tier == 1))
					{
						Log.Info("\t" + ((Object)current4).name + ":" + Language.GetString(current4.nameToken));
					}
				}
			}
			finally
			{
				((IDisposable)enumerator4).Dispose();
			}
			Log.Info("Items with ai_blacklist tag");
			Enumerator<ItemDef> enumerator5 = ItemCatalog.allItemDefs.GetEnumerator();
			try
			{
				while (enumerator5.MoveNext())
				{
					ItemDef current5 = enumerator5.Current;
					if (current5.tags.Contains((ItemTag)4))
					{
						Log.Info("\t" + ((Object)current5).name + ":" + Language.GetString(current5.nameToken));
					}
				}
			}
			finally
			{
				((IDisposable)enumerator5).Dispose();
			}
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCGetActiveModifiers(ConCommandArgs args)
		{
			Log.Info("Getting synced modifiers");
			if (!((Object)(object)StageModifierDirector.instance != (Object)null))
			{
				return;
			}
			SyncListModifier modifiersSynced = StageModifierDirector.instance.modifiersSynced;
			if (modifiersSynced != null)
			{
				if (((SyncListStruct<ModifierSync>)modifiersSynced).Count > 0)
				{
					foreach (ModifierSync item in (SyncList<ModifierSync>)(object)modifiersSynced)
					{
						Log.Info($"{item.name}:{item.stack}");
					}
					return;
				}
				Log.Info("There are no modifiers");
			}
			else
			{
				Log.Error("Modifiers list is null");
			}
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCGetSyncedData(ConCommandArgs args)
		{
			Log.Info("Getting synced modifiers");
			if ((Object)(object)StageModifierDirector.instance != (Object)null)
			{
				Log.Info("Modifiers synced");
				{
					foreach (ModifierSync item in (SyncList<ModifierSync>)(object)StageModifierDirector.instance.modifiersSynced)
					{
						Log.Info($"{item.name}:{item.stack}:{item.isArtifact}");
					}
					return;
				}
			}
			Log.Info("StageModifierDirector is null");
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCGetReservedModifiers(ConCommandArgs args)
		{
			if ((Object)(object)StageModifierDirector.instance != (Object)null)
			{
				List<ModifierSync> reservedModifiers = StageModifierDirector.instance.reservedModifiers;
				if (reservedModifiers != null)
				{
					if (reservedModifiers.Count > 0)
					{
						foreach (ModifierSync item in reservedModifiers)
						{
							Log.Info(item);
						}
						return;
					}
					Log.Info("There are no modifiers");
				}
				else
				{
					Log.Error("Modifiers list is null");
				}
			}
			else
			{
				Log.Error("It is null");
			}
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCFindShopPortal(ConCommandArgs args)
		{
			GameObject val = GameObject.Find("Node");
			if ((Object)(object)val == (Object)null)
			{
				Log.Error("Could not find it");
				return;
			}
			Log.Info("Found it");
			Component[] componentsInChildren = val.GetComponentsInChildren<Component>();
			foreach (Component val2 in componentsInChildren)
			{
				Log.Info(((object)val2).GetType());
			}
			SceneExitController component = val.GetComponent<SceneExitController>();
			Log.Info(component.destinationScene);
			Log.Info(component.useRunNextStageScene);
		}
	}
	[Serializable]
	public struct ModifierSync : IEquatable<ModifierSync>
	{
		public string name;

		public int stack;

		public bool isArtifact;

		public ModifierSync(ModifierDef mod)
		{
			name = mod.name;
			stack = 1;
			isArtifact = mod.isArtifact;
		}

		public ModifierSync(ModifierDef mod, int stack)
		{
			name = mod.name;
			this.stack = stack;
			isArtifact = mod.isArtifact;
		}

		public bool Equals(ModifierSync other)
		{
			return name == other.name;
		}
	}
	[Serializable]
	public struct RouteNodeSync : IEquatable<RouteNodeSync>
	{
		public RoutePortalType portalType;

		public int x;

		public int y;

		public int frontX;

		public int frontY;

		public int leftX;

		public int leftY;

		public int rightX;

		public int rightY;

		public int bonusX;

		public int bonusY;

		public bool visited;

		public bool shopVisited;

		public bool goldshoresVisited;

		public bool voidFieldsVisited;

		public RouteNodeSync(RouteMap.RouteNode node)
		{
			x = -1;
			y = -1;
			frontX = -1;
			frontY = -1;
			leftX = -1;
			leftY = -1;
			rightX = -1;
			rightY = -1;
			bonusX = -1;
			bonusY = -1;
			x = node.x;
			y = node.y;
			visited = node.visited;
			portalType = node.portalType;
			RouteMap.RouteNode front = node.front;
			if (front != null)
			{
				frontX = front.x;
				frontY = front.y;
			}
			RouteMap.RouteNode left = node.left;
			if (left != null)
			{
				leftX = left.x;
				leftY = left.y;
			}
			RouteMap.RouteNode right = node.right;
			if (node.right != null)
			{
				rightX = right.x;
				rightY = right.y;
			}
			if (node.portalNode != null)
			{
				bonusX = node.portalNode.x;
				bonusY = node.portalNode.y;
			}
			shopVisited = node.shopVisited;
			goldshoresVisited = node.goldshoresVisited;
			voidFieldsVisited = node.voidFieldsVisited;
		}

		public bool Equals(RouteNodeSync other)
		{
			return x == other.x && y == other.y && visited == other.visited && portalType == other.portalType && frontX == other.frontX && frontY == other.frontY && leftX == other.leftX && leftY == other.leftY && rightX == other.rightX && rightY == other.rightY && bonusX == other.bonusX && bonusY == other.bonusY;
		}
	}
	public class SyncListModifier : SyncListStruct<ModifierSync>
	{
		public override void SerializeItem(NetworkWriter writer, ModifierSync item)
		{
			writer.Write(item.name);
			writer.WritePackedUInt32((uint)item.stack);
			writer.Write(item.isArtifact);
		}

		public override ModifierSync DeserializeItem(NetworkReader reader)
		{
			ModifierSync result = default(ModifierSync);
			result.name = reader.ReadString();
			result.stack = (int)reader.ReadPackedUInt32();
			result.isArtifact = reader.ReadBoolean();
			return result;
		}
	}
	public class SyncListRouteNode : SyncListStruct<RouteNodeSync>
	{
		public override void SerializeItem(NetworkWriter writer, RouteNodeSync item)
		{
			writer.Write((int)item.portalType);
			writer.WritePackedUInt32((uint)item.x);
			writer.WritePackedUInt32((uint)item.y);
			writer.WritePackedUInt32((uint)item.frontX);
			writer.WritePackedUInt32((uint)item.frontY);
			writer.WritePackedUInt32((uint)item.leftX);
			writer.WritePackedUInt32((uint)item.leftY);
			writer.WritePackedUInt32((uint)item.rightX);
			writer.WritePackedUInt32((uint)item.rightY);
			writer.WritePackedUInt32((uint)item.bonusX);
			writer.WritePackedUInt32((uint)item.bonusY);
			writer.Write(item.visited);
			writer.Write(item.shopVisited);
			writer.Write(item.goldshoresVisited);
			writer.Write(item.voidFieldsVisited);
		}

		public override RouteNodeSync DeserializeItem(NetworkReader reader)
		{
			RouteNodeSync result = default(RouteNodeSync);
			result.portalType = (RoutePortalType)reader.ReadInt32();
			result.x = (int)reader.ReadPackedUInt32();
			result.y = (int)reader.ReadPackedUInt32();
			result.frontX = (int)reader.ReadPackedUInt32();
			result.frontY = (int)reader.ReadPackedUInt32();
			result.leftX = (int)reader.ReadPackedUInt32();
			result.leftY = (int)reader.ReadPackedUInt32();
			result.rightX = (int)reader.ReadPackedUInt32();
			result.rightY = (int)reader.ReadPackedUInt32();
			result.bonusX = (int)reader.ReadPackedUInt32();
			result.bonusY = (int)reader.ReadPackedUInt32();
			result.visited = reader.ReadBoolean();
			result.shopVisited = reader.ReadBoolean();
			result.goldshoresVisited = reader.ReadBoolean();
			result.voidFieldsVisited = reader.ReadBoolean();
			return result;
		}
	}
	public class ModifierSlotConfiguration
	{
		public Dictionary<ModifierTier, int> positive = new Dictionary<ModifierTier, int>();

		public Dictionary<ModifierTier, int> negative = new Dictionary<ModifierTier, int>();
	}
	public class StageModifierDirector : NetworkBehaviour
	{
		public static StageModifierDirector instance;

		public static List<GameObject> activePortalInstances;

		public List<string> runArtifactsApplied;

		public SyncListModifier modifiersSynced = new SyncListModifier();

		public List<RouteNodeSync> routeNodesSynced = new List<RouteNodeSync>();

		public int mapState = 0;

		public float stageEnterTime = 0f;

		[SyncVar]
		public int mapWidth;

		[SyncVar]
		public int mapHeight;

		[SyncVar]
		public bool isMoonVisited;

		[SyncVar]
		public Vector2 currentNodeSync = new Vector2(-1f, -1f);

		public int uniqueModifierLimit = 5;

		public Inventory monsterTeamInventory;

		public RouteMap routeMap;

		public RouteMap.RouteNode currentNode;

		[SyncVar(hook = "OnBaseCurseSyncedUpdate")]
		public float syncedBaseCurse = 0f;

		[SyncVar]
		public int soulCostStack = 0;

		public int commandAddedStack = 0;

		[SyncVar]
		public float punishmentTime = -1f;

		[SyncVar]
		public bool purifyLunarItemModifier;

		[SyncVar]
		public int doppelStackTime = 30;

		[SyncVar]
		public bool modifiersCanBeBanned = true;

		[SyncVar]
		public bool enemyItemsModifierCanStack = false;

		[SyncVar]
		public int commonDefaultStack = 5;

		[SyncVar]
		public int uncommonDefaultStack = 3;

		[SyncVar]
		public int legendaryDefaultStack = 1;

		[SyncVar]
		public int bossDefaultStack = 1;

		[SyncVar]
		public int commonExtraRange = 3;

		[SyncVar]
		public int uncommonExtraRange = 2;

		[SyncVar]
		public int legendaryExtraRange = 1;

		[SyncVar]
		public int bossExtraRange = 1;

		[SyncVar]
		public int chanceForExtra = 0;

		private static int kListmodifiersSynced;

		private static int kRpcRpcReceiveFullMap;

		public List<StageModifier> activeModifiers { get; set; }

		public List<ModifierSync> reservedModifiers { get; set; }

		public HashSet<string> bannedModifiersRun { get; set; }

		public HashSet<string> bannedModifiersStage { get; set; }

		public int NetworkmapWidth
		{
			get
			{
				return mapWidth;
			}
			[param: In]
			set
			{
				((NetworkBehaviour)this).SetSyncVar<int>(value, ref mapWidth, 2u);
			}
		}

		public int NetworkmapHeight
		{
			get
			{
				return mapHeight;
			}
			[param: In]
			set
			{
				((NetworkBehaviour)this).SetSyncVar<int>(value, ref mapHeight, 4u);
			}
		}

		public bool NetworkisMoonVisited
		{
			get
			{
				return isMoonVisited;
			}
			[param: In]
			set
			{
				((NetworkBehaviour)this).SetSyncVar<bool>(value, ref isMoonVisited, 8u);
			}
		}

		public Vector2 NetworkcurrentNodeSync
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return currentNodeSync;
			}
			[param: In]
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				((NetworkBehaviour)this).SetSyncVar<Vector2>(value, ref currentNodeSync, 16u);
			}
		}

		public float NetworksyncedBaseCurse
		{
			get
			{
				return syncedBaseCurse;
			}
			[param: In]
			set
			{
				ref float reference = ref syncedBaseCurse;
				if (NetworkServer.localClientActive && !((NetworkBehaviour)this).syncVarHookGuard)
				{
					((NetworkBehaviour)this).syncVarHookGuard = true;
					OnBaseCurseSyncedUpdate(value);
					((NetworkBehaviour)this).syncVarHookGuard = false;
				}
				((NetworkBehaviour)this).SetSyncVar<float>(value, ref reference, 32u);
			}
		}

		public int NetworksoulCostStack
		{
			get
			{
				return soulCostStack;
			}
			[param: In]
			set
			{
				((NetworkBehaviour)this).SetSyncVar<int>(value, ref soulCostStack, 64u);
			}
		}

		public float NetworkpunishmentTime
		{
			get
			{
				return punishmentTime;
			}
			[param: In]
			set
			{
				((NetworkBehaviour)this).SetSyncVar<float>(value, ref punishmentTime, 128u);
			}
		}

		public bool NetworkpurifyLunarItemModifier
		{
			get
			{
				return purifyLunarItemModifier;
			}
			[param: In]
			set
			{
				((NetworkBehaviour)this).SetSyncVar<bool>(value, ref purifyLunarItemModifier, 256u);
			}
		}

		public int NetworkdoppelStackTime
		{
			get
			{
				return doppelStackTime;
			}
			[param: In]
			set
			{
				((NetworkBehaviour)this).SetSyncVar<int>(value, ref doppelStackTime, 512u);
			}
		}

		public bool NetworkmodifiersCanBeBanned
		{
			get
			{
				return modifiersCanBeBanned;
			}
			[param: In]
			set
			{
				((NetworkBehaviour)this).SetSyncVar<bool>(value, ref modifiersCanBeBanned, 1024u);
			}
		}

		public bool NetworkenemyItemsModifierCanStack
		{
			get
			{
				return enemyItemsModifierCanStack;
			}
			[param: In]
			set
			{
				((NetworkBehaviour)this).SetSyncVar<bool>(value, ref enemyItemsModifierCanStack, 2048u);
			}
		}

		public int NetworkcommonDefaultStack
		{
			get
			{
				return commonDefaultStack;
			}
			[param: In]
			set
			{
				((NetworkBehaviour)this).SetSyncVar<int>(value, ref commonDefaultStack, 4096u);
			}
		}

		public int NetworkuncommonDefaultStack
		{
			get
			{
				return uncommonDefaultStack;
			}
			[param: In]
			set
			{
				((NetworkBehaviour)this).SetSyncVar<int>(value, ref uncommonDefaultStack, 8192u);
			}
		}

		public int NetworklegendaryDefaultStack
		{
			get
			{
				return legendaryDefaultStack;
			}
			[param: In]
			set
			{
				((NetworkBehaviour)this).SetSyncVar<int>(value, ref legendaryDefaultStack, 16384u);
			}
		}

		public int NetworkbossDefaultStack
		{
			get
			{
				return bossDefaultStack;
			}
			[param: In]
			set
			{
				((NetworkBehaviour)this).SetSyncVar<int>(value, ref bossDefaultStack, 32768u);
			}
		}

		public int NetworkcommonExtraRange
		{
			get
			{
				return commonExtraRange;
			}
			[param: In]
			set
			{
				((NetworkBehaviour)this).SetSyncVar<int>(value, ref commonExtraRange, 65536u);
			}
		}

		public int NetworkuncommonExtraRange
		{
			get
			{
				return uncommonExtraRange;
			}
			[param: In]
			set
			{
				((NetworkBehaviour)this).SetSyncVar<int>(value, ref uncommonExtraRange, 131072u);
			}
		}

		public int NetworklegendaryExtraRange
		{
			get
			{
				return legendaryExtraRange;
			}
			[param: In]
			set
			{
				((NetworkBehaviour)this).SetSyncVar<int>(value, ref legendaryExtraRange, 262144u);
			}
		}

		public int NetworkbossExtraRange
		{
			get
			{
				return bossExtraRange;
			}
			[param: In]
			set
			{
				((NetworkBehaviour)this).SetSyncVar<int>(value, ref bossExtraRange, 524288u);
			}
		}

		public int NetworkchanceForExtra
		{
			get
			{
				return chanceForExtra;
			}
			[param: In]
			set
			{
				((NetworkBehaviour)this).SetSyncVar<int>(value, ref chanceForExtra, 1048576u);
			}
		}

		public void Awake()
		{
			instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			activeModifiers = new List<StageModifier>();
			reservedModifiers = new List<ModifierSync>();
			bannedModifiersRun = new HashSet<string>();
			bannedModifiersStage = new HashSet<string>();
			activePortalInstances = new List<GameObject>();
			Log.Info("Awake: StageModifierDirector created");
			if (NetworkServer.active)
			{
				Run.onRunStartGlobal += Run_onRunStartGlobal;
				Run.onRunDestroyGlobal += Run_onRunDestroyGlobal;
				SceneDirector.onPrePopulateSceneServer += SceneDirector_onPrePopulateSceneServer;
				Stage.onServerStageComplete += Stage_onServerStageComplete;
			}
			((SyncList<ModifierSync>)(object)modifiersSynced).InitializeBehaviour((NetworkBehaviour)(object)this, kListmodifiersSynced);
		}

		public void OnDestroy()
		{
			Run.onRunDestroyGlobal -= Run_onRunDestroyGlobal;
			Run.onRunStartGlobal -= Run_onRunStartGlobal;
			SceneDirector.onPrePopulateSceneServer -= SceneDirector_onPrePopulateSceneServer;
			Stage.onServerStageComplete -= Stage_onServerStageComplete;
		}

		private void Run_onRunStartGlobal(Run run)
		{
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			Log.Info("Run_onRunStartGlobal: Run started");
			if (NetworkServer.active)
			{
				GameObject val = Object.Instantiate<GameObject>(global::RiskOfRoutes.RiskOfRoutes.networkedInventoryPrefab);
				Object.DontDestroyOnLoad((Object)(object)val);
				monsterTeamInventory = val.GetComponent<Inventory>();
				val.GetComponent<TeamFilter>().teamIndex = (TeamIndex)2;
				NetworkServer.Spawn(val);
				CreateRunConfiguration();
				Log.Info(string.Format("{0}: Got punishmentTimeMinutes value - {1}", "Run_onRunStartGlobal", punishmentTime));
				Log.Info("Creating route map");
				routeMap = new RouteMap(run.runRNG);
				currentNode = routeMap.GetStartingNode();
				currentNode.visited = true;
				NetworkcurrentNodeSync = new Vector2((float)currentNode.x, (float)currentNode.y);
				Log.Info($"Current:{currentNode.x},{currentNode.y} that has {currentNode.GetPaths().Count} paths");
				routeMap.isDirty = true;
			}
		}

		private void CreateRunConfiguration()
		{
			NetworkenemyItemsModifierCanStack = global::RiskOfRoutes.RiskOfRoutes.enemyItemsModifierCanStack.Value;
			NetworkcommonDefaultStack = global::RiskOfRoutes.RiskOfRoutes.commonDefaultStack.Value;
			NetworkuncommonDefaultStack = global::RiskOfRoutes.RiskOfRoutes.uncommonDefaultStack.Value;
			NetworklegendaryDefaultStack = global::RiskOfRoutes.RiskOfRoutes.legendaryDefaultStack.Value;
			NetworkbossDefaultStack = global::RiskOfRoutes.RiskOfRoutes.bossDefaultStack.Value;
			NetworkcommonExtraRange = global::RiskOfRoutes.RiskOfRoutes.commonExtraRange.Value;
			NetworkuncommonExtraRange = global::RiskOfRoutes.RiskOfRoutes.uncommonExtraRange.Value;
			NetworklegendaryExtraRange = global::RiskOfRoutes.RiskOfRoutes.legendaryExtraRange.Value;
			NetworkbossExtraRange = global::RiskOfRoutes.RiskOfRoutes.bossExtraRange.Value;
			NetworkchanceForExtra = global::RiskOfRoutes.RiskOfRoutes.chanceForExtra.Value;
			runArtifactsApplied = GetArtifactsAppliedThisRun();
			if (global::RiskOfRoutes.RiskOfRoutes.negativeStackPunishment.Value)
			{
				NetworkpunishmentTime = global::RiskOfRoutes.RiskOfRoutes.punishmentTimeMinutes.Value;
			}
			else
			{
				NetworkpunishmentTime = -1f;
			}
			NetworkpurifyLunarItemModifier = global::RiskOfRoutes.RiskOfRoutes.lunarTurnToPearl.Value;
			NetworkdoppelStackTime = global::RiskOfRoutes.RiskOfRoutes.doppelStackTime.Value;
			NetworkmodifiersCanBeBanned = global::RiskOfRoutes.RiskOfRoutes.modifiersCanBeBanned.Value;
			bannedModifiersRun.Clear();
			if (!global::RiskOfRoutes.RiskOfRoutes.allowAurelioniteModifier.Value)
			{
				bannedModifiersRun.Add("Aurelionite");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowBossRedItemModifier.Value)
			{
				bannedModifiersRun.Add("BossRedItem");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowBossYellowItemModifier.Value)
			{
				bannedModifiersRun.Add("BossYellowItem");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowDroneBossGreenModifier.Value)
			{
				bannedModifiersRun.Add("DroneBossGreen");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowDroneBossRedModifier.Value)
			{
				bannedModifiersRun.Add("DroneBossRed");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowMoreElitesModifier.Value)
			{
				bannedModifiersRun.Add("MoreElites");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowMoreDronesModifier.Value)
			{
				bannedModifiersRun.Add("MoreDrones");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowUpgradeDronesModifier.Value)
			{
				bannedModifiersRun.Add("UpgradeDrones");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowLunarEnemiesModifier.Value)
			{
				bannedModifiersRun.Add("LunarEnemies");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowVoidEnemiesModifier.Value)
			{
				bannedModifiersRun.Add("VoidEnemies");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowYellowPrinterModifier.Value)
			{
				bannedModifiersRun.Add("YellowPrinter");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowRedPrinterModifier.Value)
			{
				bannedModifiersRun.Add("RedPrinter");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowOnlyFlyingModifier.Value)
			{
				bannedModifiersRun.Add("OnlyFlying");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowPowerfulElitesModifier.Value)
			{
				bannedModifiersRun.Add("PowerfulElites");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowRepairModifier.Value)
			{
				bannedModifiersRun.Add("Repair");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowWanderingChefModifier.Value)
			{
				bannedModifiersRun.Add("WanderingChef");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowMountainModifier.Value)
			{
				bannedModifiersRun.Add("Mountain");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowSoulCostModifier.Value)
			{
				bannedModifiersRun.Add("SoulCost");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowDoppelgangerModifier.Value)
			{
				bannedModifiersRun.Add("Doppelganger");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowMysteryArtifact.Value)
			{
				bannedModifiersRun.Add("Mystery");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowChaosArtifact.Value)
			{
				bannedModifiersRun.Add("FriendlyFire");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowCommandArtifact.Value)
			{
				bannedModifiersRun.Add("Command");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowDelusionArtifact.Value)
			{
				bannedModifiersRun.Add("Delusion");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowDevotionArtifact.Value)
			{
				bannedModifiersRun.Add("Devotion");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowDissonanceArtifact.Value)
			{
				bannedModifiersRun.Add("MixEnemy");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowEnigmaArtifact.Value)
			{
				bannedModifiersRun.Add("Enigma");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowEvolutionArtifact.Value)
			{
				bannedModifiersRun.Add("MonsterTeamGainsItems");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowFrailtyArtifact.Value)
			{
				bannedModifiersRun.Add("WeakAssKnees");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowGlassArtifact.Value)
			{
				bannedModifiersRun.Add("Glass");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowHonorArtifact.Value)
			{
				bannedModifiersRun.Add("EliteOnly");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowKinArtifact.Value)
			{
				bannedModifiersRun.Add("SingleMonsterType");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowMetamorphosisArtifact.Value)
			{
				bannedModifiersRun.Add("RandomSurvivorOnRespawn");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowRebirthArtifact.Value)
			{
				bannedModifiersRun.Add("Rebirth");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowSacrificeArtifact.Value)
			{
				bannedModifiersRun.Add("Sacrifice");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowSoulArtifact.Value)
			{
				bannedModifiersRun.Add("WispOnDeath");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowSpiteArtifact.Value)
			{
				bannedModifiersRun.Add("Bomb");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowSwarmsArtifact.Value)
			{
				bannedModifiersRun.Add("Swarms");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowVengeanceArtifact.Value)
			{
				bannedModifiersRun.Add("ShadowClone");
			}
			if (!global::RiskOfRoutes.RiskOfRoutes.allowDeathArtifact.Value)
			{
				bannedModifiersRun.Add("TeamDeath");
			}
			StageModifierCatalog.CreateRunPools(global::RiskOfRoutes.RiskOfRoutes.printerItemPool.Value, global::RiskOfRoutes.RiskOfRoutes.lunarItemPool.Value, global::RiskOfRoutes.RiskOfRoutes.enemyItemPool.Value, global::RiskOfRoutes.RiskOfRoutes.canAppearWithAIBlacklisted.Value, global::RiskOfRoutes.RiskOfRoutes.enemyItemsAllowBoss.Value, global::RiskOfRoutes.RiskOfRoutes.enemyItemsAllowVoid.Value, bannedModifiersRun);
			List<string> list = (from s in global::RiskOfRoutes.RiskOfRoutes.tier1EnemyItems.Value.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries)
				select s.Trim()).ToList();
			List<string> list2 = (from s in global::RiskOfRoutes.RiskOfRoutes.tier2EnemyItems.Value.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries)
				select s.Trim()).ToList();
			List<string> list3 = (from s in global::RiskOfRoutes.RiskOfRoutes.tier3EnemyItems.Value.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries)
				select s.Trim()).ToList();
			List<string> list4 = (from s in global::RiskOfRoutes.RiskOfRoutes.tier1PrinterItems.Value.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries)
				select s.Trim()).ToList();
			List<string> list5 = (from s in global::RiskOfRoutes.RiskOfRoutes.tier2PrinterItems.Value.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries)
				select s.Trim()).ToList();
			List<string> list6 = (from s in global::RiskOfRoutes.RiskOfRoutes.tier3PrinterItems.Value.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries)
				select s.Trim()).ToList();
			List<string> list7 = (from s in global::RiskOfRoutes.RiskOfRoutes.tier1LunarItems.Value.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries)
				select s.Trim()).ToList();
			List<string> list8 = (from s in global::RiskOfRoutes.RiskOfRoutes.tier2LunarItems.Value.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries)
				select s.Trim()).ToList();
			List<string> list9 = (from s in global::RiskOfRoutes.RiskOfRoutes.tier3LunarItems.Value.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries)
				select s.Trim()).ToList();
			List<string> list10 = (from s in global::RiskOfRoutes.RiskOfRoutes.tier1Artifacts.Value.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries)
				select s.Trim()).ToList();
			List<string> list11 = (from s in global::RiskOfRoutes.RiskOfRoutes.tier2Artifacts.Value.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries)
				select s.Trim()).ToList();
			List<string> list12 = (from s in global::RiskOfRoutes.RiskOfRoutes.tier3Artifacts.Value.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries)
				select s.Trim()).ToList();
			foreach (string item in list)
			{
				StageModifierCatalog.TryRegEnemy(item, ModifierTier.Tier1, isAdditional: true);
				Log.Info(item + " registering as Tier1 enemy item");
			}
			foreach (string item2 in list2)
			{
				StageModifierCatalog.TryRegEnemy(item2, ModifierTier.Tier2, isAdditional: true);
				Log.Info(item2 + " registering as Tier2 enemy item");
			}
			foreach (string item3 in list3)
			{
				StageModifierCatalog.TryRegEnemy(item3, ModifierTier.Tier3, isAdditional: true);
				Log.Info(item3 + " registering as Tier3 enemy item");
			}
			foreach (string item4 in list4)
			{
				StageModifierCatalog.TryRegPrinter(item4, ModifierTier.Tier1, isAdditional: true);
				Log.Info(item4 + " registering as Tier1 printer item");
			}
			foreach (string item5 in list5)
			{
				StageModifierCatalog.TryRegPrinter(item5, ModifierTier.Tier2, isAdditional: true);
				Log.Info(item5 + " registering as Tier2 printer item");
			}
			foreach (string item6 in list6)
			{
				StageModifierCatalog.TryRegPrinter(item6, ModifierTier.Tier3, isAdditional: true);
				Log.Info(item6 + " registering as Tier3 printer item");
			}
			foreach (string item7 in list7)
			{
				StageModifierCatalog.TryRegLunar(item7, ModifierTier.Tier1, isAdditional: true);
				Log.Info(item7 + " registering as Tier1 lunar item");
			}
			foreach (string item8 in list8)
			{
				StageModifierCatalog.TryRegLunar(item8, ModifierTier.Tier2, isAdditional: true);
				Log.Info(item8 + " registering as Tier2 lunar item");
			}
			foreach (string item9 in list9)
			{
				StageModifierCatalog.TryRegLunar(item9, ModifierTier.Tier3, isAdditional: true);
				Log.Info(item9 + " registering as Tier3 lunar item");
			}
			foreach (string item10 in list10)
			{
				StageModifierCatalog.TryRegArtifact(new ArtifactInfo(item10, 1, isNegative: true), isAdditional: true);
				Log.Info(item10 + " registering as Tier1 artifact");
			}
			foreach (string item11 in list11)
			{
				StageModifierCatalog.TryRegArtifact(new ArtifactInfo(item11, 2, isNegative: true), isAdditional: true);
				Log.Info(item11 + " registering as Tier2 artifact");
			}
			foreach (string item12 in list12)
			{
				StageModifierCatalog.TryRegArtifact(new ArtifactInfo(item12, 3, isNegative: true), isAdditional: true);
				Log.Info(item12 + " registering as Tier3 artifact");
			}
		}

		private void OnEnable()
		{
			Stage.onStageStartGlobal += OnStageStartClient;
		}

		private void OnDisable()
		{
			Stage.onStageStartGlobal -= OnStageStartClient;
		}

		private void OnStageStartClient(Stage obj)
		{
			if (!NetworkServer.active)
			{
				Log.Info("OnStageStartClient: on client");
				LocalUser firstLocalUser = LocalUserManager.GetFirstLocalUser();
				NetworkUser val = ((firstLocalUser != null) ? firstLocalUser.currentNetworkUser : null);
				if (!((Object)(object)val == (Object)null))
				{
					Console.instance.SubmitCmd(val, "request_map", false);
				}
			}
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCRequestMap(ConCommandArgs args)
		{
			if ((Object)(object)instance != (Object)null && instance.routeMap != null)
			{
				Log.Info("CCRequestMap: requested the map");
				instance.routeMap.isDirty = true;
			}
		}

		protected virtual void FixedUpdate()
		{
			if (NetworkServer.active && routeMap != null && routeMap.isDirty)
			{
				UpdateRouteMap();
				routeMap.isDirty = false;
			}
		}

		private void UpdateRouteMap()
		{
			Log.Info("UpdateRouteMap: Updating route map");
			int width = routeMap.width;
			int height = routeMap.height;
			RouteNodeSync[] array = new RouteNodeSync[(width + 1) * height];
			for (int i = 0; i < width + 1; i++)
			{
				for (int j = 0; j < height; j++)
				{
					int num = i * height + j;
					if (routeMap.mapGrid[i, j] != null)
					{
						array[num] = new RouteNodeSync(routeMap.mapGrid[i, j]);
					}
					else
					{
						array[num] = new RouteNodeSync(new RouteMap.RouteNode(-1, -1));
					}
				}
			}
			NetworkmapWidth = width;
			NetworkmapHeight = height;
			NetworkisMoonVisited = routeMap.isMoonVisited;
			routeNodesSynced = new List<RouteNodeSync>(array);
			CallRpcReceiveFullMap(array, width, height, routeMap.isMoonVisited, stageEnterTime);
		}

		[ClientRpc]
		private void RpcReceiveFullMap(RouteNodeSync[] map, int width, int height, bool moon, float hostStageEnterTime)
		{
			NetworkmapWidth = width;
			NetworkmapHeight = height;
			NetworkisMoonVisited = moon;
			routeNodesSynced = new List<RouteNodeSync>(map);
			mapState++;
			stageEnterTime = hostStageEnterTime;
			Debug.Log((object)"RpcReceiveFullMap: Got map on client");
		}

		private void Run_onRunDestroyGlobal(Run obj)
		{
			if (!NetworkServer.active)
			{
				return;
			}
			Log.Info(string.Format("{0}: Run ended, clearing {1} modifiers", "Run_onRunDestroyGlobal", activeModifiers.Count));
			foreach (StageModifier activeModifier in activeModifiers)
			{
				if (activeModifier == null)
				{
					Log.Error("Run_onRunDestroyGlobal: Some active modifier is null");
				}
				else
				{
					activeModifier.OnEnd();
				}
			}
			reservedModifiers.Clear();
			runArtifactsApplied.Clear();
			((SyncList<ModifierSync>)(object)modifiersSynced).Clear();
			routeNodesSynced.Clear();
			if (Object.op_Implicit((Object)(object)((Component)this).gameObject))
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				Log.Info("Run_onRunDestroyGlobal: StageModifierDirector destroyed");
			}
			if (Object.op_Implicit((Object)(object)monsterTeamInventory))
			{
				NetworkServer.Destroy(((Component)monsterTeamInventory).gameObject);
			}
			monsterTeamInventory = null;
		}

		private void OnBaseCurseSyncedUpdate(float newValue)
		{
			NetworksyncedBaseCurse = newValue;
			foreach (CharacterMaster readOnlyInstances in CharacterMaster.readOnlyInstancesList)
			{
				if (!((Object)(object)readOnlyInstances.playerCharacterMasterController == (Object)null) && Object.op_Implicit((Object)(object)readOnlyInstances) && Object.op_Implicit((Object)(object)readOnlyInstances.GetBody()))
				{
					readOnlyInstances.GetBody().RecalculateStats();
				}
			}
		}

		public List<string> GetArtifactsAppliedThisRun()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = new List<string>();
			RunEnabledArtifacts enumerator = RunArtifactManager.enabledArtifactsEnumerable.GetEnumerator();
			try
			{
				while (((RunEnabledArtifacts)(ref enumerator)).MoveNext())
				{
					ArtifactDef current = ((RunEnabledArtifacts)(ref enumerator)).Current;
					list.Add(current.cachedName);
					Log.Info("Added " + current.cachedName);
				}
			}
			finally
			{
				((IDisposable)(RunEnabledArtifacts)(ref enumerator)).Dispose();
			}
			return list;
		}

		private void SceneDirector_onPrePopulateSceneServer(SceneDirector obj)
		{
			Log.Info(string.Format("{0}: Stage started, applying {1} modifiers", "SceneDirector_onPrePopulateSceneServer", reservedModifiers.Count));
			if (reservedModifiers.Count == 0)
			{
				return;
			}
			Log.Info(reservedModifiers.Count);
			activeModifiers.Clear();
			bannedModifiersStage.Clear();
			Log.Info("Active");
			foreach (ModifierSync reservedModifier in reservedModifiers)
			{
				StageModifier stageModifier = StageModifierCatalog.StageModifierFromDef(reservedModifier.name, reservedModifier.stack);
				if (stageModifier == null)
				{
					Log.Error("SceneDirector_onPrePopulateSceneServer: Modifier with def " + reservedModifier.name + " is null");
					continue;
				}
				activeModifiers.Add(stageModifier);
				if (modifiersCanBeBanned)
				{
					bannedModifiersStage.Add(reservedModifier.name);
				}
			}
			foreach (ModifierSync reservedModifier2 in reservedModifiers)
			{
				((SyncList<ModifierSync>)(object)modifiersSynced).Add(reservedModifier2);
				if (reservedModifier2.name == "SoulCost")
				{
					NetworksoulCostStack = reservedModifier2.stack;
				}
			}
			foreach (StageModifier activeModifier in activeModifiers)
			{
				activeModifier.OnStart();
			}
			activePortalInstances.Clear();
			reservedModifiers.Clear();
			SceneDef sceneDefForCurrentScene = SceneCatalog.GetSceneDefForCurrentScene();
			stageEnterTime = Run.instance.GetRunStopwatch();
		}

		private void Stage_onServerStageComplete(Stage obj)
		{
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Invalid comparison between Unknown and I4
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			Log.Info($"Stage completed, clearing {activeModifiers.Count} modifiers");
			foreach (StageModifier activeModifier in activeModifiers)
			{
				activeModifier.OnEnd();
			}
			activeModifiers.Clear();
			((SyncList<ModifierSync>)(object)modifiersSynced).Clear();
			Log.Info($"Modul:{Stage.instance.sceneDef.stageOrder}");
			if (Stage.instance.sceneDef.stageOrder == 5 || (currentNode.x == 0 && currentNode.y == 0 && Stage.instance.sceneDef.baseSceneName != "bazaar" && (int)Stage.instance.sceneDef.sceneType == 1))
			{
				Log.Info("Trying to create new map");
				if (Object.op_Implicit((Object)(object)TeleporterInteraction.instance) && TeleporterInteraction.instance.sceneExitController.destinationScene.baseSceneName == "moon2" && TeleporterInteraction.instance.isCharged)
				{
					routeMap.isMoonVisited = true;
				}
				else
				{
					routeMap = new RouteMap(Run.instance.runRNG);
					Log.Info("Created new map");
					currentNode = routeMap.GetStartingNode();
					NetworkcurrentNodeSync = new Vector2((float)currentNode.x, (float)currentNode.y);
					Log.Info($"Current:{currentNode.x},{currentNode.y} that has {currentNode.GetPaths().Count} paths");
					Log.Info($"Teleporter:{TeleporterInteraction.instance.sceneExitController.useRunNextStageScene}");
				}
			}
			else
			{
				Log.Info("Not creating new map yet");
				Log.Info($"\t{currentNode.x}:{currentNode.y}");
				Log.Info($"\t{Stage.instance.sceneDef.stageOrder}");
			}
			currentNode.visited = true;
			routeMap.isDirty = true;
		}

		public void GetNextStageModifiers(GameObject portal)
		{
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Invalid comparison between I4 and Unknown
			RoutePortalManager component = portal.GetComponent<RoutePortalManager>();
			if ((Object)(object)component == (Object)null || component.routeNode == null)
			{
				Log.Error("GetNextStageModifiers: Portal doesn't have routePortalManager or RouteNode, couldn't get modifiers.");
				return;
			}
			HashSet<string> hashSet = new HashSet<string>(bannedModifiersRun);
			hashSet.UnionWith(bannedModifiersStage);
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			ModifierSlotConfiguration modifierSlots = GetModifierSlots(Run.instance.stageRng, component.routeNode.portalType, hashSet);
			if (SceneHelper.IsSceneColossus((SceneIndex)component.destinationSceneIndex, includeFalseSonScene: false))
			{
				if (!bannedModifiersRun.Contains("Aurelionite"))
				{
					dictionary.Add("Aurelionite", 1);
					Log.Info("GetNextStageModifiers: Added aurelionite modifier to colossus portal");
				}
				else
				{
					Log.Warning("Not adding aurelionite reward to collosus portal because modifier is banned");
				}
			}
			if (component.destinationSceneIndex == (int)SceneCatalog.FindSceneIndex("conduitcanyon"))
			{
				List<string> list = new List<string> { "UpgradeDrones", "DroneBossRed" };
				dictionary.Add(Run.instance.stageRng.NextElementUniform<string>(list), 1);
				Log.Info("GetNextStageModifiers: Added rare drone modifier to hardware portal");
			}
			if (component.routeNode.portalType == RoutePortalType.ChefType)
			{
				if (!bannedModifiersRun.Contains("WanderingChef"))
				{
					dictionary.Add("WanderingChef", 1);
					Log.Info("GetNextStageModifiers: Added chef modifier to route portal");
				}
				else
				{
					Log.Warning("Not adding wandering chef to chef portal because modifier is banned");
				}
			}
			if (CheckMountainShrine() && Run.instance.stageRng.nextNormalizedFloat > 0.5f && !bannedModifiersRun.Contains("Mountain"))
			{
				dictionary.Add("Mountain", TeleporterInteraction.instance.shrineBonusStacks);
			}
			if (CheckPlayersHaveConsumedItems() && Run.instance.stageRng.nextNormalizedFloat > 0.8f && !bannedModifiersRun.Contains("Repair"))
			{
				dictionary.Add("Repair", 1);
			}
			Dictionary<ModifierTier, int> positive = modifierSlots.positive;
			foreach (KeyValuePair<ModifierTier, int> item in positive)
			{
				for (int i = 0; i < item.Value; i++)
				{
					List<string> pool = StageModifierCatalog.GetPool(component.routeNode.portalType);
					ModifierDef modifierDef = StageModifierCatalog.SelectModifier(hashSet, component.routeNode.portalType, item.Key, pool);
					if (modifierDef == null)
					{
						continue;
					}
					hashSet.Add(modifierDef.name);
					if (modifierDef.conflictList != null)
					{
						foreach (string conflict in modifierDef.conflictList)
						{
							hashSet.Add(conflict);
						}
					}
					int num = CalculateStack(modifierDef, item.Key);
					if (dictionary.ContainsKey(modifierDef.name))
					{
						dictionary[modifierDef.name] += num;
					}
					else
					{
						dictionary.Add(modifierDef.name, num);
					}
				}
			}
			Dictionary<ModifierTier, int> negative = modifierSlots.negative;
			List<ModifierDef> list2 = new List<ModifierDef>();
			foreach (KeyValuePair<ModifierTier, int> item2 in negative)
			{
				for (int j = 0; j < item2.Value; j++)
				{
					List<string> pool2 = StageModifierCatalog.GetPool(component.routeNode.portalType, isNegative: true);
					ModifierDef modifierDef2 = StageModifierCatalog.SelectModifier(hashSet, component.routeNode.portalType, item2.Key, pool2);
					if (modifierDef2 == null)
					{
						continue;
					}
					hashSet.Add(modifierDef2.name);
					if (modifierDef2.conflictList != null)
					{
						foreach (string conflict2 in modifierDef2.conflictList)
						{
							hashSet.Add(conflict2);
						}
					}
					int num2 = CalculateStack(modifierDef2, item2.Key);
					if (dictionary.ContainsKey(modifierDef2.name))
					{
						dictionary[modifierDef2.name] += num2;
						continue;
					}
					dictionary.Add(modifierDef2.name, num2);
					list2.Add(modifierDef2);
				}
			}
			int num3 = (int)((Run.instance.GetRunStopwatch() - stageEnterTime) / (punishmentTime * 60f));
			num3 += commandAddedStack;
			if (num3 > 0)
			{
				Log.Info(string.Format("{0}: Adding {1} punishment stacks", "GetNextStageModifiers", num3));
			}
			IEnumerable<ModifierDef> source = list2.Where((ModifierDef s) => s.isStackable);
			if (num3 > 0)
			{
				if (source.Count() == 0)
				{
					Log.Warning("GetNextStageModifiers: There are no stackable negative modifiers to apply punish, adding new");
					List<string> pool3 = StageModifierCatalog.GetPool(component.routeNode.portalType, isNegative: true);
					while (num3 > 0)
					{
						int num4 = Mathf.Min(num3, 3);
						int num5 = Run.instance.stageRng.RangeInt(1, num4 + 1);
						ModifierTier tier = (ModifierTier)num5;
						ModifierDef modifierDef3 = StageModifierCatalog.SelectModifier(hashSet, component.routeNode.portalType, tier, pool3);
						while (modifierDef3 == null && num5 > 1)
						{
							num5--;
							tier = (ModifierTier)num5;
							modifierDef3 = StageModifierCatalog.SelectModifier(hashSet, component.routeNode.portalType, tier, pool3);
						}
						if (modifierDef3 == null)
						{
							Log.Warning("GetNextStageModifiers: Couldnt add new negative modifiers");
							break;
						}
						hashSet.Add(modifierDef3.name);
						if (modifierDef3.conflictList != null)
						{
							foreach (string conflict3 in modifierDef3.conflictList)
							{
								hashSet.Add(conflict3);
							}
						}
						num3 -= num5;
						int num6 = 0;
						if (num3 > 0 && modifierDef3.isStackable)
						{
							num6 = Run.instance.stageRng.RangeInt(0, num3 + 1);
							num3 -= num6;
						}
						dictionary.Add(modifierDef3.name, 1 + num6);
						Log.Info(string.Format("{0}: Punish added new modifier {1} with stack {2}", "GetNextStageModifiers", modifierDef3.name, 1 + num6));
					}
				}
				else
				{
					for (int k = 0; k < num3; k++)
					{
						ModifierDef modifierDef4 = Run.instance.stageRng.NextElementUniform<ModifierDef>(source.ToArray());
						if (dictionary.ContainsKey(modifierDef4.name))
						{
							dictionary[modifierDef4.name]++;
							Log.Info("GetNextStageModifiers: Added 1 additional stack to " + modifierDef4.name);
						}
					}
				}
			}
			List<ModifierSync> list3 = new List<ModifierSync>();
			foreach (KeyValuePair<string, int> item3 in dictionary)
			{
				ModifierDef modifierDef5 = StageModifierCatalog.FindModifier(item3.Key);
				if (modifierDef5 == null)
				{
					return;
				}
				list3.Add(new ModifierSync(modifierDef5, item3.Value));
			}
			((SyncList<string>)(object)component.stageModifiers).Clear();
			foreach (ModifierSync item4 in list3)
			{
				((SyncList<string>)(object)component.stageModifiers).Add($"{item4.name}={item4.stack}={item4.isArtifact}");
			}
		}

		private int CalculateStack(ModifierDef def, ModifierTier targetTier)
		{
			ModifierTier tier = def.tier;
			if (tier == targetTier)
			{
				return 1;
			}
			if ((tier == ModifierTier.Tier1 && targetTier == ModifierTier.Tier2) || (tier == ModifierTier.Tier2 && targetTier == ModifierTier.Tier3))
			{
				return 2;
			}
			if (tier == ModifierTier.Tier1 && targetTier == ModifierTier.Tier3)
			{
				return 3;
			}
			return 1;
		}

		public static ModifierSlotConfiguration GetModifierSlots(Xoroshiro128Plus rng, RoutePortalType type, HashSet<string> banned)
		{
			WeightedSelection<ModifierSlotConfiguration> val = new WeightedSelection<ModifierSlotConfiguration>(8);
			if (type != RoutePortalType.Rare)
			{
				val.AddChoice(new ModifierSlotConfiguration
				{
					positive = { 
					{
						ModifierTier.Tier1,
						1
					} },
					negative = { 
					{
						ModifierTier.Tier1,
						1
					} }
				}, 1f);
				val.AddChoice(new ModifierSlotConfiguration
				{
					positive = { 
					{
						ModifierTier.Tier1,
						2
					} },
					negative = { 
					{
						ModifierTier.Tier2,
						1
					} }
				}, 1f);
				val.AddChoice(new ModifierSlotConfiguration
				{
					positive = { 
					{
						ModifierTier.Tier2,
						1
					} },
					negative = { 
					{
						ModifierTier.Tier1,
						2
					} }
				}, 1f);
			}
			val.AddChoice(new ModifierSlotConfiguration
			{
				positive = { 
				{
					ModifierTier.Tier3,
					1
				} },
				negative = { 
				{
					ModifierTier.Tier3,
					1
				} }
			}, 0.3f);
			val.AddChoice(new ModifierSlotConfiguration
			{
				positive = { 
				{
					ModifierTier.Tier3,
					1
				} },
				negative = 
				{
					{
						ModifierTier.Tier2,
						1
					},
					{
						ModifierTier.Tier1,
						1
					}
				}
			}, 0.3f);
			ModifierSlotConfiguration modifierSlotConfiguration = val.Evaluate(rng.nextNormalizedFloat);
			if (modifierSlotConfiguration.positive.ContainsKey(ModifierTier.Tier3))
			{
				List<string> pool = StageModifierCatalog.GetPool(type);
				if (StageModifierCatalog.SelectModifier(banned, type, ModifierTier.Tier3, pool) == null)
				{
					Log.Warning(string.Format("{0}: Couldnt get Tier3 modifier for node type {1}, using Tier2", "GetModifierSlots", type));
					modifierSlotConfiguration.positive.Remove(ModifierTier.Tier3);
					if (modifierSlotConfiguration.positive.ContainsKey(ModifierTier.Tier2))
					{
						modifierSlotConfiguration.positive[ModifierTier.Tier2] = modifierSlotConfiguration.positive[ModifierTier.Tier2] + 1;
					}
					else
					{
						modifierSlotConfiguration.positive.Add(ModifierTier.Tier2, 2);
					}
				}
			}
			return modifierSlotConfiguration;
		}

		public bool IsModifierActive(string name)
		{
			foreach (ModifierSync item in (SyncList<ModifierSync>)(object)modifiersSynced)
			{
				if (item.name == name)
				{
					return true;
				}
			}
			return false;
		}

		public void AddRoutePortalInstance(GameObject portal)
		{
			if ((Object)(object)portal == (Object)null)
			{
				Log.Error("AddRoutePortalInstance: Route portal is null, cant add instance");
				return;
			}
			RoutePortalManager component = portal.GetComponent<RoutePortalManager>();
			if ((Object)(object)component == (Object)null)
			{
				Log.Error("AddRoutePortalInstance: Route portal manager is null, cant add instance");
			}
			activePortalInstances.Add(portal);
		}

		public void GetModifiersFromRandomPortal()
		{
			if (activePortalInstances == null || activePortalInstances.Count == 0)
			{
				Log.Warning("GetModifiersFromRandomPortal: There are no portal instances to get modifiers from");
				return;
			}
			GameObject val = Run.instance.stageRng.NextElementUniform<GameObject>(activePortalInstances);
			RoutePortalManager component = val.GetComponent<RoutePortalManager>();
			if ((Object)(object)component == (Object)null)
			{
				Log.Warning("GetModifiersFromRandomPortal: Route portal manager is null, cant get modifiers");
				return;
			}
			reservedModifiers.Clear();
			foreach (string item in (SyncList<string>)(object)component.stageModifiers)
			{
				string[] array = item.Split('=');
				instance.reservedModifiers.Add(new ModifierSync
				{
					name = array[0],
					stack = int.Parse(array[1])
				});
			}
			foreach (GameObject activePortalInstance in activePortalInstances)
			{
				GenericInteraction component2 = activePortalInstance.GetComponent<GenericInteraction>();
				if ((Object)(object)component2 != (Object)null)
				{
					((Behaviour)component2).enabled = false;
				}
			}
		}

		public void GetRouteNodeFromRandomPortal()
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			if (activePortalInstances == null || activePortalInstances.Count == 0)
			{
				Log.Warning("GetRouteNodeFromRandomPortal: There are no portal active instances to get routeNode from");
				return;
			}
			Log.Info(string.Format("{0}: Trying to get routeNode from {1} portal instances", "GetRouteNodeFromRandomPortal", activePortalInstances.Count));
			GameObject val = Run.instance.stageRng.NextElementUniform<GameObject>(activePortalInstances);
			RoutePortalManager component = val.GetComponent<RoutePortalManager>();
			if ((Object)(object)component == (Object)null)
			{
				Log.Warning("GetRouteNodeFromRandomPortal: Selected portal instance missing RoutePortalManager");
				return;
			}
			currentNode = component.routeNode;
			NetworkcurrentNodeSync = new Vector2((float)currentNode.x, (float)currentNode.y);
			foreach (GameObject activePortalInstance in activePortalInstances)
			{
				GenericInteraction component2 = activePortalInstance.GetComponent<GenericInteraction>();
				if ((Object)(object)component2 != (Object)null)
				{
					((Behaviour)component2).enabled = false;
				}
			}
		}

		[Server]
		public bool CheckPlayersRedItem()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Invalid comparison between Unknown and I4
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkServer.active)
			{
				Debug.LogWarning((object)"[Server] function 'System.Boolean SamplePlugin.StageModifierDirector::CheckPlayersRedItem()' called on client");
				return false;
			}
			int num = 0;
			foreach (CharacterMaster readOnlyInstances in CharacterMaster.readOnlyInstancesList)
			{
				if ((Object)(object)readOnlyInstances.playerCharacterMasterController == (Object)null)
				{
					continue;
				}
				foreach (ItemIndex item in readOnlyInstances.inventory.itemAcquisitionOrder)
				{
					ItemDef itemDef = ItemCatalog.GetItemDef(item);
					if ((Object)(object)itemDef != (Object)null && (int)itemDef.tier == 2)
					{
						num += readOnlyInstances.inventory.GetItemCount(item);
						Log.Info(string.Format("{0}: Found red item:{1}", "CheckPlayersRedItem", itemDef));
					}
				}
			}
			Log.Info(string.Format("{0}: Players have {1} red items right now", "CheckPlayersRedItem", num));
			return num > 0;
		}

		[Server]
		public bool CheckPlayersYellowItem()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Invalid comparison between Unknown and I4
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkServer.active)
			{
				Debug.LogWarning((object)"[Server] function 'System.Boolean SamplePlugin.StageModifierDirector::CheckPlayersYellowItem()' called on client");
				return false;
			}
			int num = 0;
			foreach (CharacterMaster readOnlyInstances in CharacterMaster.readOnlyInstancesList)
			{
				if ((Object)(object)readOnlyInstances.playerCharacterMasterController == (Object)null || !Object.op_Implicit((Object)(object)readOnlyInstances.inventory))
				{
					continue;
				}
				foreach (ItemIndex item in readOnlyInstances.inventory.itemAcquisitionOrder)
				{
					ItemDef itemDef = ItemCatalog.GetItemDef(item);
					if ((Object)(object)itemDef != (Object)null && (int)itemDef.tier == 4)
					{
						num += readOnlyInstances.inventory.GetItemCount(item);
						Log.Info(string.Format("{0}: Found yellow item:{1}", "CheckPlayersYellowItem", itemDef));
					}
				}
			}
			Log.Info(string.Format("{0}: Players have {1} yellow items right now", "CheckPlayersYellowItem", num));
			return num > 0;
		}

		[Server]
		public bool CheckPlayersHaveConsumedItems()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkServer.active)
			{
				Debug.LogWarning((object)"[Server] function 'System.Boolean SamplePlugin.StageModifierDirector::CheckPlayersHaveConsumedItems()' called on client");
				return false;
			}
			int num = 0;
			foreach (CharacterMaster readOnlyInstances in CharacterMaster.readOnlyInstancesList)
			{
				if ((Object)(object)readOnlyInstances.playerCharacterMasterController == (Object)null || !Object.op_Implicit((Object)(object)readOnlyInstances.inventory))
				{
					continue;
				}
				foreach (ItemIndex item in readOnlyInstances.inventory.itemAcquisitionOrder)
				{
					ItemDef itemDef = ItemCatalog.GetItemDef(item);
					if ((Object)(object)itemDef != (Object)null && itemDef.isConsumed && (Object)(object)itemDef != (Object)(object)Items.RegeneratingScrapConsumed && (Object)(object)itemDef != (Object)(object)Items.LowerPricedChestsConsumed && (Object)(object)itemDef != (Object)(object)Items.TeleportOnLowHealthConsumed)
					{
						num++;
					}
				}
			}
			Log.Info($"Players have {num} consumed items right now");
			return num > 0;
		}

		[Server]
		public bool CheckMountainShrine()
		{
			if (!NetworkServer.active)
			{
				Debug.LogWarning((object)"[Server] function 'System.Boolean SamplePlugin.StageModifierDirector::CheckMountainShrine()' called on client");
				return false;
			}
			if (Object.op_Implicit((Object)(object)TeleporterInteraction.instance))
			{
				return TeleporterInteraction.instance.shrineBonusStacks > 0;
			}
			return false;
		}

		[Server]
		public bool CheckArtifactOfDeathAvailable()
		{
			if (!NetworkServer.active)
			{
				Debug.LogWarning((object)"[Server] function 'System.Boolean SamplePlugin.StageModifierDirector::CheckArtifactOfDeathAvailable()' called on client");
				return false;
			}
			return Run.instance.participatingPlayerCount > 1 && !runArtifactsApplied.Contains("TeamDeath");
		}

		[Server]
		public bool CheckArtifactAvailable(string name)
		{
			if (!NetworkServer.active)
			{
				Debug.LogWarning((object)"[Server] function 'System.Boolean SamplePlugin.StageModifierDirector::CheckArtifactAvailable(System.String)' called on client");
				return false;
			}
			return !runArtifactsApplied.Contains(name);
		}

		[Server]
		public int CheckPlayersHaveFoodItems()
		{
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkServer.active)
			{
				Debug.LogWarning((object)"[Server] function 'System.Int32 SamplePlugin.StageModifierDirector::CheckPlayersHaveFoodItems()' called on client");
				return 0;
			}
			List<ItemDef> list = new List<ItemDef>
			{
				Items.FlatHealth,
				Items.Mushroom,
				Items.Infusion,
				Items.HealWhileSafe,
				Items.MushroomVoid
			};
			int num = 0;
			foreach (CharacterMaster readOnlyInstances in CharacterMaster.readOnlyInstancesList)
			{
				if ((Object)(object)readOnlyInstances.playerCharacterMasterController == (Object)null || !Object.op_Implicit((Object)(object)readOnlyInstances.inventory))
				{
					continue;
				}
				foreach (ItemIndex item in readOnlyInstances.inventory.itemAcquisitionOrder)
				{
					ItemDef itemDef = ItemCatalog.GetItemDef(item);
					if ((Object)(object)itemDef != (Object)null && list.Contains(itemDef))
					{
						num += readOnlyInstances.inventory.GetItemCount(itemDef);
					}
				}
			}
			Log.Info($"Players have {num} food related items right now");
			return num;
		}

		public List<RouteMap.RouteNode> GetAvailableNodes()
		{
			if (currentNode != null)
			{
				return currentNode.GetPaths();
			}
			Log.Error("GetAvailableNodes: Current node is null");
			return null;
		}

		private void UNetVersion()
		{
		}

		protected static void InvokeSyncListmodifiersSynced(NetworkBehaviour obj, NetworkReader reader)
		{
			if (!NetworkClient.active)
			{
				Debug.LogError((object)"SyncList modifiersSynced called on server.");
			}
			else
			{
				((SyncList<ModifierSync>)(object)((StageModifierDirector)(object)obj).modifiersSynced).HandleMsg(reader);
			}
		}

		protected static void InvokeRpcRpcReceiveFullMap(NetworkBehaviour obj, NetworkReader reader)
		{
			if (!NetworkClient.active)
			{
				Debug.LogError((object)"RPC RpcReceiveFullMap called on server.");
			}
			else
			{
				((StageModifierDirector)(object)obj).RpcReceiveFullMap(GeneratedNetworkCode._ReadArrayRouteNodeSync_None(reader), (int)reader.ReadPackedUInt32(), (int)reader.ReadPackedUInt32(), reader.ReadBoolean(), reader.ReadSingle());
			}
		}

		public void CallRpcReceiveFullMap(RouteNodeSync[] map, int width, int height, bool moon, float hostStageEnterTime)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkServer.active)
			{
				Debug.LogError((object)"RPC Function RpcReceiveFullMap called on client.");
				return;
			}
			NetworkWriter val = new NetworkWriter();
			val.Write((short)0);
			val.Write((short)2);
			val.WritePackedUInt32((uint)kRpcRpcReceiveFullMap);
			val.Write(((Component)this).GetComponent<NetworkIdentity>().netId);
			GeneratedNetworkCode._WriteArrayRouteNodeSync_None(val, map);
			val.WritePackedUInt32((uint)width);
			val.WritePackedUInt32((uint)height);
			val.Write(moon);
			val.Write(hostStageEnterTime);
			((NetworkBehaviour)this).SendRPCInternal(val, 0, "RpcReceiveFullMap");
		}

		static StageModifierDirector()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			kRpcRpcReceiveFullMap = -1012231583;
			NetworkBehaviour.RegisterRpcDelegate(typeof(StageModifierDirector), kRpcRpcReceiveFullMap, new CmdDelegate(InvokeRpcRpcReceiveFullMap));
			kListmodifiersSynced = -163976013;
			NetworkBehaviour.RegisterSyncListDelegate(typeof(StageModifierDirector), kListmodifiersSynced, new CmdDelegate(InvokeSyncListmodifiersSynced));
			NetworkCRC.RegisterBehaviour("StageModifierDirector", 0);
		}

		public override bool OnSerialize(NetworkWriter writer, bool forceAll)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			if (forceAll)
			{
				GeneratedNetworkCode._WriteStructSyncListModifier_None(writer, modifiersSynced);
				writer.WritePackedUInt32((uint)mapWidth);
				writer.WritePackedUInt32((uint)mapHeight);
				writer.Write(isMoonVisited);
				writer.Write(currentNodeSync);
				writer.Write(syncedBaseCurse);
				writer.WritePackedUInt32((uint)soulCostStack);
				writer.Write(punishmentTime);
				writer.Write(purifyLunarItemModifier);
				writer.WritePackedUInt32((uint)doppelStackTime);
				writer.Write(modifiersCanBeBanned);
				writer.Write(enemyItemsModifierCanStack);
				writer.WritePackedUInt32((uint)commonDefaultStack);
				writer.WritePackedUInt32((uint)uncommonDefaultStack);
				writer.WritePackedUInt32((uint)legendaryDefaultStack);
				writer.WritePackedUInt32((uint)bossDefaultStack);
				writer.WritePackedUInt32((uint)commonExtraRange);
				writer.WritePackedUInt32((uint)uncommonExtraRange);
				writer.WritePackedUInt32((uint)legendaryExtraRange);
				writer.WritePackedUInt32((uint)bossExtraRange);
				writer.WritePackedUInt32((uint)chanceForExtra);
				return true;
			}
			bool flag = false;
			if ((((NetworkBehaviour)this).syncVarDirtyBits & (true ? 1u : 0u)) != 0)
			{
				if (!flag)
				{
					writer.WritePackedUInt32(((NetworkBehaviour)this).syncVarDirtyBits);
					flag = true;
				}
				GeneratedNetworkCode._WriteStructSyncListModifier_None(writer, modifiersSynced);
			}
			if ((((NetworkBehaviour)this).syncVarDirtyBits & 2u) != 0)
			{
				if (!flag)
				{
					writer.WritePackedUInt32(((NetworkBehaviour)this).syncVarDirtyBits);
					flag = true;
				}
				writer.WritePackedUInt32((uint)mapWidth);
			}
			if ((((NetworkBehaviour)this).syncVarDirtyBits & 4u) != 0)
			{
				if (!flag)
				{
					writer.WritePackedUInt32(((NetworkBehaviour)this).syncVarDirtyBits);
					flag = true;
				}
				writer.WritePackedUInt32((uint)mapHeight);
			}
			if ((((NetworkBehaviour)this).syncVarDirtyBits & 8u) != 0)
			{
				if (!flag)
				{
					writer.WritePackedUInt32(((NetworkBehaviour)this).syncVarDirtyBits);
					flag = true;
				}
				writer.Write(isMoonVisited);
			}
			if ((((NetworkBehaviour)this).syncVarDirtyBits & 0x10u) != 0)
			{
				if (!flag)
				{
					writer.WritePackedUInt32(((NetworkBehaviour)this).syncVarDirtyBits);
					flag = true;
				}
				writer.Write(currentNodeSync);
			}
			if ((((NetworkBehaviour)this).syncVarDirtyBits & 0x20u) != 0)
			{
				if (!flag)
				{
					writer.WritePackedUInt32(((NetworkBehaviour)this).syncVarDirtyBits);
					flag = true;
				}
				writer.Write(syncedBaseCurse);
			}
			if ((((NetworkBehaviour)this).syncVarDirtyBits & 0x40u) != 0)
			{
				if (!flag)
				{
					writer.WritePackedUInt32(((NetworkBehaviour)this).syncVarDirtyBits);
					flag = true;
				}
				writer.WritePackedUInt32((uint)soulCostStack);
			}
			if ((((NetworkBehaviour)this).syncVarDirtyBits & 0x80u) != 0)
			{
				if (!flag)
				{
					writer.WritePackedUInt32(((NetworkBehaviour)this).syncVarDirtyBits);
					flag = true;
				}
				writer.Write(punishmentTime);
			}
			if ((((NetworkBehaviour)this).syncVarDirtyBits & 0x100u) != 0)
			{
				if (!flag)
				{
					writer.WritePackedUInt32(((NetworkBehaviour)this).syncVarDirtyBits);
					flag = true;
				}
				writer.Write(purifyLunarItemModifier);
			}
			if ((((NetworkBehaviour)this).syncVarDirtyBits & 0x200u) != 0)
			{
				if (!flag)
				{
					writer.WritePackedUInt32(((NetworkBehaviour)this).syncVarDirtyBits);
					flag = true;
				}
				writer.WritePackedUInt32((uint)doppelStackTime);
			}
			if ((((NetworkBehaviour)this).syncVarDirtyBits & 0x400u) != 0)
			{
				if (!flag)
				{
					writer.WritePackedUInt32(((NetworkBehaviour)this).syncVarDirtyBits);
					flag = true;
				}
				writer.Write(modifiersCanBeBanned);
			}
			if ((((NetworkBehaviour)this).syncVarDirtyBits & 0x800u) != 0)
			{
				if (!flag)
				{
					writer.WritePackedUInt32(((NetworkBehaviour)this).syncVarDirtyBits);
					flag = true;
				}
				writer.Write(enemyItemsModifierCanStack);
			}
			if ((((NetworkBehaviour)this).syncVarDirtyBits & 0x1000u) != 0)
			{
				if (!flag)
				{
					writer.WritePackedUInt32(((NetworkBehaviour)this).syncVarDirtyBits);
					flag = true;
				}
				writer.WritePackedUInt32((uint)commonDefaultStack);
			}
			if ((((NetworkBehaviour)this).syncVarDirtyBits & 0x2000u) != 0)
			{
				if (!flag)
				{
					writer.WritePackedUInt32(((NetworkBehaviour)this).syncVarDirtyBits);
					flag = true;
				}
				writer.WritePackedUInt32((uint)uncommonDefaultStack);
			}
			if ((((NetworkBehaviour)this).syncVarDirtyBits & 0x4000u) != 0)
			{
				if (!flag)
				{
					writer.WritePackedUInt32(((NetworkBehaviour)this).syncVarDirtyBits);
					flag = true;
				}
				writer.WritePackedUInt32((uint)legendaryDefaultStack);
			}
			if ((((NetworkBehaviour)this).syncVarDirtyBits & 0x8000u) != 0)
			{
				if (!flag)
				{
					writer.WritePackedUInt32(((NetworkBehaviour)this).syncVarDirtyBits);
					flag = true;
				}
				writer.WritePackedUInt32((uint)bossDefaultStack);
			}
			if ((((NetworkBehaviour)this).syncVarDirtyBits & 0x10000u) != 0)
			{
				if (!flag)
				{
					writer.WritePackedUInt32(((NetworkBehaviour)this).syncVarDirtyBits);
					flag = true;
				}
				writer.WritePackedUInt32((uint)commonExtraRange);
			}
			if ((((NetworkBehaviour)this).syncVarDirtyBits & 0x20000u) != 0)
			{
				if (!flag)
				{
					writer.WritePackedUInt32(((NetworkBehaviour)this).syncVarDirtyBits);
					flag = true;
				}
				writer.WritePackedUInt32((uint)uncommonExtraRange);
			}
			if ((((NetworkBehaviour)this).syncVarDirtyBits & 0x40000u) != 0)
			{
				if (!flag)
				{
					writer.WritePackedUInt32(((NetworkBehaviour)this).syncVarDirtyBits);
					flag = true;
				}
				writer.WritePackedUInt32((uint)legendaryExtraRange);
			}
			if ((((NetworkBehaviour)this).syncVarDirtyBits & 0x80000u) != 0)
			{
				if (!flag)
				{
					writer.WritePackedUInt32(((NetworkBehaviour)this).syncVarDirtyBits);
					flag = true;
				}
				writer.WritePackedUInt32((uint)bossExtraRange);
			}
			if ((((NetworkBehaviour)this).syncVarDirtyBits & 0x100000u) != 0)
			{
				if (!flag)
				{
					writer.WritePackedUInt32(((NetworkBehaviour)this).syncVarDirtyBits);
					flag = true;
				}
				writer.WritePackedUInt32((uint)chanceForExtra);
			}
			if (!flag)
			{
				writer.WritePackedUInt32(((NetworkBehaviour)this).syncVarDirtyBits);
			}
			return flag;
		}

		public override void OnDeserialize(NetworkReader reader, bool initialState)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			if (initialState)
			{
				GeneratedNetworkCode._ReadStructSyncListModifier_None(reader, modifiersSynced);
				mapWidth = (int)reader.ReadPackedUInt32();
				mapHeight = (int)reader.ReadPackedUInt32();
				isMoonVisited = reader.ReadBoolean();
				currentNodeSync = reader.ReadVector2();
				syncedBaseCurse = reader.ReadSingle();
				soulCostStack = (int)reader.ReadPackedUInt32();
				punishmentTime = reader.ReadSingle();
				purifyLunarItemModifier = reader.ReadBoolean();
				doppelStackTime = (int)reader.ReadPackedUInt32();
				modifiersCanBeBanned = reader.ReadBoolean();
				enemyItemsModifierCanStack = reader.ReadBoolean();
				commonDefaultStack = (int)reader.ReadPackedUInt32();
				uncommonDefaultStack = (int)reader.ReadPackedUInt32();
				legendaryDefaultStack = (int)reader.ReadPackedUInt32();
				bossDefaultStack = (int)reader.ReadPackedUInt32();
				commonExtraRange = (int)reader.ReadPackedUInt32();
				uncommonExtraRange = (int)reader.ReadPackedUInt32();
				legendaryExtraRange = (int)reader.ReadPackedUInt32();
				bossExtraRange = (int)reader.ReadPackedUInt32();
				chanceForExtra = (int)reader.ReadPackedUInt32();
				return;
			}
			int num = (int)reader.ReadPackedUInt32();
			if (((uint)num & (true ? 1u : 0u)) != 0)
			{
				GeneratedNetworkCode._ReadStructSyncListModifier_None(reader, modifiersSynced);
			}
			if (((uint)num & 2u) != 0)
			{
				mapWidth = (int)reader.ReadPackedUInt32();
			}
			if (((uint)num & 4u) != 0)
			{
				mapHeight = (int)reader.ReadPackedUInt32();
			}
			if (((uint)num & 8u) != 0)
			{
				isMoonVisited = reader.ReadBoolean();
			}
			if (((uint)num & 0x10u) != 0)
			{
				currentNodeSync = reader.ReadVector2();
			}
			if (((uint)num & 0x20u) != 0)
			{
				OnBaseCurseSyncedUpdate(reader.ReadSingle());
			}
			if (((uint)num & 0x40u) != 0)
			{
				soulCostStack = (int)reader.ReadPackedUInt32();
			}
			if (((uint)num & 0x80u) != 0)
			{
				punishmentTime = reader.ReadSingle();
			}
			if (((uint)num & 0x100u) != 0)
			{
				purifyLunarItemModifier = reader.ReadBoolean();
			}
			if (((uint)num & 0x200u) != 0)
			{
				doppelStackTime = (int)reader.ReadPackedUInt32();
			}
			if (((uint)num & 0x400u) != 0)
			{
				modifiersCanBeBanned = reader.ReadBoolean();
			}
			if (((uint)num & 0x800u) != 0)
			{
				enemyItemsModifierCanStack = reader.ReadBoolean();
			}
			if (((uint)num & 0x1000u) != 0)
			{
				commonDefaultStack = (int)reader.ReadPackedUInt32();
			}
			if (((uint)num & 0x2000u) != 0)
			{
				uncommonDefaultStack = (int)reader.ReadPackedUInt32();
			}
			if (((uint)num & 0x4000u) != 0)
			{
				legendaryDefaultStack = (int)reader.ReadPackedUInt32();
			}
			if (((uint)num & 0x8000u) != 0)
			{
				bossDefaultStack = (int)reader.ReadPackedUInt32();
			}
			if (((uint)num & 0x10000u) != 0)
			{
				commonExtraRange = (int)reader.ReadPackedUInt32();
			}
			if (((uint)num & 0x20000u) != 0)
			{
				uncommonExtraRange = (int)reader.ReadPackedUInt32();
			}
			if (((uint)num & 0x40000u) != 0)
			{
				legendaryExtraRange = (int)reader.ReadPackedUInt32();
			}
			if (((uint)num & 0x80000u) != 0)
			{
				bossExtraRange = (int)reader.ReadPackedUInt32();
			}
			if (((uint)num & 0x100000u) != 0)
			{
				chanceForExtra = (int)reader.ReadPackedUInt32();
			}
		}
	}
}
namespace SamplePlugin.StageModifiers
{
	public abstract class StageModifier
	{
		public int stack = 1;

		public abstract void OnStart();

		public abstract void OnEnd();

		protected GameObject TryPlaceObjectOnScene(SpawnCard spawnCard, string name = "object")
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkServer.active)
			{
				return null;
			}
			if ((Object)(object)spawnCard == (Object)null)
			{
				Log.Error("Something went wrong with " + name + " spawncard");
				return null;
			}
			if (!Object.op_Implicit((Object)(object)Run.instance))
			{
				return null;
			}
			Log.Info("Trying to place " + name);
			GameObject val = null;
			for (int i = 0; i < 15; i++)
			{
				DirectorPlacementRule val2 = new DirectorPlacementRule
				{
					placementMode = (PlacementMode)4
				};
				val = DirectorCore.instance.TrySpawnObject(new DirectorSpawnRequest(spawnCard, val2, Run.instance.stageRng));
				if (Object.op_Implicit((Object)(object)val))
				{
					Log.Info($"Succesfully placed {name} on {val.transform.position}");
					break;
				}
				Log.Error("Failed to place " + name + ", retrying");
			}
			if ((Object)(object)val == (Object)null)
			{
				Log.Error("It was impossible to place " + name);
			}
			return val;
		}
	}
}
namespace SamplePlugin.StageModifiers.SceneModifiers
{
	public class MoreDronesModifier : StageModifier
	{
		public MoreDronesModifier(int stack)
		{
			base.stack = stack;
		}

		public override void OnEnd()
		{
			Log.Info("MoreDronesModifier end");
		}

		public override void OnStart()
		{
			Log.Info("MoreDronesModifier start");
			PopulateDrones();
		}

		public void PopulateDrones()
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Invalid comparison between Unknown and I4
			int num = 0;
			int sceneDirectorInteractibleCredits = ClassicStageInfo.instance.sceneDirectorInteractibleCredits;
			float num2 = (float)global::RiskOfRoutes.RiskOfRoutes.droneStackPercent.Value / 100f;
			Log.Info($"Drone stack percent is {num2}");
			int num3 = (int)((float)(sceneDirectorInteractibleCredits * stack) * num2);
			Log.Info("Spawning more drones");
			ClassicStageInfo instance = ClassicStageInfo.instance;
			WeightedSelection<DirectorCard> val = new WeightedSelection<DirectorCard>(8);
			Category val2 = ((IEnumerable<Category>)instance.interactableCategories.categories).FirstOrDefault((Func<Category, bool>)((Category c) => c.name == "Drones"));
			if (val2.cards.Length == 0)
			{
				Log.Error("No drones available on stage");
				return;
			}
			DirectorCard[] cards = val2.cards;
			foreach (DirectorCard val3 in cards)
			{
				if (val3.IsAvailable())
				{
					val.AddChoice(val3, (float)val3.selectionWeight);
				}
			}
			int num4 = 100;
			while (num3 > 0 && num4 > 0)
			{
				DirectorCard val4 = SelectCard(val, num3);
				if (val4 == null)
				{
					break;
				}
				if (!val4.IsAvailable())
				{
					continue;
				}
				GameObject val5 = TryPlaceObjectOnScene(val4.spawnCard, ((Object)val4.spawnCard).name);
				if ((Object)(object)val5 != (Object)null)
				{
					PurchaseInteraction component = val5.GetComponent<PurchaseInteraction>();
					if (Object.op_Implicit((Object)(object)component) && (int)component.costType == 1)
					{
						component.Networkcost = Run.instance.GetDifficultyScaledCost(component.cost);
					}
					num3 -= val4.cost;
					num++;
				}
				num4--;
			}
			Log.Info($"Spawned {num} more drones");
		}

		private static DirectorCard SelectCard(WeightedSelection<DirectorCard> deck, int maxCost)
		{
			//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_001c: 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)
			WeightedSelection<DirectorCard> val = new WeightedSelection<DirectorCard>(maxCost);
			int i = 0;
			for (int count = deck.Count; i < count; i++)
			{
				ChoiceInfo<DirectorCard> choice = deck.GetChoice(i);
				if (choice.value.cost <= maxCost)
				{
					val.AddChoice(choice);
				}
			}
			if (val.Count == 0)
			{
				return null;
			}
			return val.Evaluate(Run.instance.stageRng.nextNormalizedFloat);
		}
	}
	public class PrinterItemModifier : StageModifier
	{
		public ItemDef selectedItem;

		public static InteractableSpawnCard printerSpawnCard;

		public PrinterItemModifier(string internalName)
		{
			selectedItem = stringToItemDef(internalName);
			if (!((Object)(object)selectedItem == (Object)null))
			{
				CreatePrinterSpawnCard();
			}
		}

		public static ItemDef stringToItemDef(string selectedItemName)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			ItemIndex val = ItemCatalog.FindItemIndex(selectedItemName);
			if ((int)val != -1)
			{
				return ItemCatalog.GetItemDef(val);
			}
			Log.Error("Error finding item");
			return null;
		}

		public override void OnEnd()
		{
			Log.Info("PrinterItemModifier end");
		}

		public override void OnStart()
		{
			Log.Info("PrinterItemModifier start");
			SpawnPrinter();
		}

		private void SpawnPrinter()
		{
			//IL_0038: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = TryPlaceObjectOnScene((SpawnCard)(object)printerSpawnCard, "Printer with " + ((Object)selectedItem).name);
			if (Object.op_Implicit((Object)(object)val))
			{
				Log.Info($"printer appeared at {val.transform.position} on stage");
				ShopTerminalBehavior component = val.GetComponent<ShopTerminalBehavior>();
				component.dropTable = null;
				component.selfGeneratePickup = false;
				component.itemTier = selectedItem.tier;
				PickupIndex pickupIndex = PickupCatalog.FindPickupIndex(selectedItem.itemIndex);
				UniquePickup val2 = default(UniquePickup);
				val2.pickupIndex = pickupIndex;
				UniquePickup val3 = val2;
				component.SetPickup(val3, false);
			}
		}

		private void CreatePrinterSpawnCard()
		{
			//IL_0007: Unknown result type (might be due to invalid