using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using DunGen;
using DunGen.Graph;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using NoteBoxz.ConfluxMod.NetcodePatcher;
using NotezyLib.MultiDungeon;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("AmazingAssets.TerrainToMesh")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp-firstpass")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("ClientNetworkTransform")]
[assembly: IgnoresAccessChecksTo("com.olegknyazev.softmask")]
[assembly: IgnoresAccessChecksTo("DissonanceVoip")]
[assembly: IgnoresAccessChecksTo("EasyTextEffects")]
[assembly: IgnoresAccessChecksTo("Facepunch Transport for Netcode for GameObjects")]
[assembly: IgnoresAccessChecksTo("Facepunch.Steamworks.Win64")]
[assembly: IgnoresAccessChecksTo("LethalLevelLoader")]
[assembly: IgnoresAccessChecksTo("Unity.AI.Navigation")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging.DocCodeExamples")]
[assembly: IgnoresAccessChecksTo("Unity.Burst")]
[assembly: IgnoresAccessChecksTo("Unity.Burst.Unsafe")]
[assembly: IgnoresAccessChecksTo("Unity.Collections")]
[assembly: IgnoresAccessChecksTo("Unity.Collections.LowLevel.ILSupport")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem.ForUI")]
[assembly: IgnoresAccessChecksTo("Unity.Jobs")]
[assembly: IgnoresAccessChecksTo("Unity.Mathematics")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.Common")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.MetricTypes")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStats")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Component")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Implementation")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsReporting")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkProfiler.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkSolutionInterface")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Networking.Transport")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Csg")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.KdTree")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Poly2Tri")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Stl")]
[assembly: IgnoresAccessChecksTo("Unity.Profiling.Core")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.ShaderLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Config.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.ShaderGraph.ShaderGraphLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Authentication")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Analytics")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Device")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Networking")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Registration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Scheduler")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Telemetry")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Threading")]
[assembly: IgnoresAccessChecksTo("Unity.Services.QoS")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Relay")]
[assembly: IgnoresAccessChecksTo("Unity.TextMeshPro")]
[assembly: IgnoresAccessChecksTo("Unity.Timeline")]
[assembly: IgnoresAccessChecksTo("Unity.VisualEffectGraph.Runtime")]
[assembly: IgnoresAccessChecksTo("UnityEngine.ARModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.NVIDIAModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.UI")]
[assembly: AssemblyCompany("NoteBoxz.ConfluxMod")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.1.8.0")]
[assembly: AssemblyInformationalVersion("0.1.8")]
[assembly: AssemblyProduct("ConfluxMod")]
[assembly: AssemblyTitle("NoteBoxz.ConfluxMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.8.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ConfluxMod
{
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("NoteBoxz.ConfluxMod", "ConfluxMod", "0.1.8")]
	public class ConfluxMod : BaseUnityPlugin
	{
		private readonly string targetSceneName = "NotezLevel2Conflux";

		private bool isPatchActive = false;

		public static readonly char[] ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray();

		public static ConfluxMod Instance { get; private set; } = null;


		internal static ManualLogSource Logger { get; private set; } = null;


		internal static Harmony? PermanentHarmony { get; set; }

		internal static Harmony? DynamicHarmony { get; set; }

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			Instance = this;
			Patch();
			NetcodePatcher();
			SceneManager.sceneLoaded += OnSceneLoaded;
			SceneManager.sceneUnloaded += OnSceneUnloaded;
			Logger.LogInfo((object)"NoteBoxz.ConfluxMod v0.1.8 has loaded!");
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			if (!(((Scene)(ref scene)).name == targetSceneName) || isPatchActive)
			{
				return;
			}
			if (DynamicHarmony == null)
			{
				DynamicHarmony = new Harmony("NoteBoxz.ConfluxMod.dynamic");
			}
			IEnumerable<Type> enumerable = from t in Assembly.GetExecutingAssembly().GetTypes()
				where t.Namespace == "ConfluxMod.MoonPatches"
				select t;
			foreach (Type item in enumerable)
			{
				DynamicHarmony.PatchAll(item);
			}
			isPatchActive = true;
			Logger.LogInfo((object)("Dynamic patches applied for " + targetSceneName));
		}

		private void OnSceneUnloaded(Scene scene)
		{
			if (((Scene)(ref scene)).name == targetSceneName && isPatchActive)
			{
				CleanUpBeforeUnPatch();
				Harmony? dynamicHarmony = DynamicHarmony;
				if (dynamicHarmony != null)
				{
					dynamicHarmony.UnpatchSelf();
				}
				isPatchActive = false;
				Logger.LogInfo((object)("Dynamic patches removed for " + targetSceneName));
			}
		}

		internal static void Patch()
		{
			//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_0018: Expected O, but got Unknown
			if (PermanentHarmony == null)
			{
				PermanentHarmony = new Harmony("NoteBoxz.ConfluxMod.permanent");
			}
			Logger.LogDebug((object)"Patching permanent patches...");
			IEnumerable<Type> enumerable = from t in Assembly.GetExecutingAssembly().GetTypes()
				where t.Namespace == "ConfluxMod.Patches"
				select t;
			foreach (Type item in enumerable)
			{
				PermanentHarmony.PatchAll(item);
				Logger.LogDebug((object)("Patched permanent type: " + item.Name));
			}
			Logger.LogDebug((object)"Finished patching!");
		}

		private void CleanUpBeforeUnPatch()
		{
		}

		internal static void Unpatch()
		{
			Logger.LogDebug((object)"Unpatching all patches...");
			Harmony? permanentHarmony = PermanentHarmony;
			if (permanentHarmony != null)
			{
				permanentHarmony.UnpatchSelf();
			}
			Harmony? dynamicHarmony = DynamicHarmony;
			if (dynamicHarmony != null)
			{
				dynamicHarmony.UnpatchSelf();
			}
			Logger.LogDebug((object)"Finished unpatching!");
		}

		private void NetcodePatcher()
		{
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			Type[] array = types;
			foreach (Type type in array)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo[] array2 = methods;
				foreach (MethodInfo methodInfo in array2)
				{
					object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
					if (customAttributes.Length != 0)
					{
						methodInfo.Invoke(null, null);
					}
				}
			}
		}
	}
	public class ConfluxBuilding : MonoBehaviour
	{
		public ConfluxBuildingType Type = ConfluxBuildingType.Factory;

		public GameObject FactoryVisuals = null;

		public GameObject ResidentialVisuals = null;

		public GameObject MainVisuals = null;

		public GameObject MineshaftVisuals = null;

		public GameObject AncientVisuals = null;

		public GameObject TowerVisuals = null;

		public Transform TowerMainPosition = null;

		public Transform AcientMainPosition = null;

		public EntranceTeleport MainEntrance = null;

		public TMP_Text DebugLabel = null;

		public string letter = "";

		[ContextMenu("SetNames")]
		public void SetNames()
		{
			ConfluxBuilding[] componentsInChildren = ((Component)((Component)this).transform.parent).GetComponentsInChildren<ConfluxBuilding>();
			foreach (ConfluxBuilding confluxBuilding in componentsInChildren)
			{
				int siblingIndex = ((Component)confluxBuilding).transform.GetSiblingIndex();
				confluxBuilding.letter = ConfluxMod.ALPHABET[siblingIndex].ToString();
				((Object)((Component)confluxBuilding).gameObject).name = $"Building{ConfluxMod.ALPHABET[siblingIndex]}";
				((Object)((Component)confluxBuilding.MainEntrance).gameObject).name = $"EntranceTeleportA{siblingIndex + 1}";
				((Object)((Component)((Component)confluxBuilding.MainEntrance).transform.parent).gameObject).name = $"Main{ConfluxMod.ALPHABET[siblingIndex]}";
			}
		}
	}
	public enum ConfluxBuildingType
	{
		Main,
		Factory,
		Residential,
		Mineshaft,
		Towner,
		Ancient
	}
	public class ConfluxMoonController : NetworkBehaviour
	{
		public Transform MainBuildingPosition = null;

		public List<Transform> BuildingPositions = new List<Transform>();

		private static readonly Dictionary<string, ConfluxBuildingType> ExactFlowMatches = new Dictionary<string, ConfluxBuildingType>
		{
			{
				"Level2Flow",
				ConfluxBuildingType.Residential
			},
			{
				"LiminalHouseFlow",
				ConfluxBuildingType.Residential
			},
			{
				"RavenFlow",
				ConfluxBuildingType.Residential
			},
			{
				"CabinDungeonFlow",
				ConfluxBuildingType.Residential
			},
			{
				"HabitatDungeonFlow",
				ConfluxBuildingType.Residential
			},
			{
				"Level3Flow",
				ConfluxBuildingType.Mineshaft
			},
			{
				"StorageComplex",
				ConfluxBuildingType.Mineshaft
			},
			{
				"RrajigarFlow",
				ConfluxBuildingType.Mineshaft
			},
			{
				"deepmines",
				ConfluxBuildingType.Mineshaft
			},
			{
				"MinesFlow",
				ConfluxBuildingType.Mineshaft
			},
			{
				"EgyptFlow",
				ConfluxBuildingType.Ancient
			},
			{
				"ChizraFlow",
				ConfluxBuildingType.Ancient
			},
			{
				"AquaticDungeonFlow",
				ConfluxBuildingType.Ancient
			},
			{
				"TowerFlow",
				ConfluxBuildingType.Towner
			},
			{
				"OfficeDungeonFlow",
				ConfluxBuildingType.Towner
			}
		};

		private static readonly Dictionary<string, ConfluxBuildingType> PartialStringMatches = new Dictionary<string, ConfluxBuildingType>
		{
			{
				"house",
				ConfluxBuildingType.Residential
			},
			{
				"home",
				ConfluxBuildingType.Residential
			},
			{
				"residential",
				ConfluxBuildingType.Residential
			},
			{
				"mine",
				ConfluxBuildingType.Mineshaft
			},
			{
				"mineshaft",
				ConfluxBuildingType.Mineshaft
			},
			{
				"tunnel",
				ConfluxBuildingType.Mineshaft
			},
			{
				"cave",
				ConfluxBuildingType.Mineshaft
			},
			{
				"ancient",
				ConfluxBuildingType.Ancient
			},
			{
				"temple",
				ConfluxBuildingType.Ancient
			},
			{
				"pyramid",
				ConfluxBuildingType.Ancient
			},
			{
				"ruin",
				ConfluxBuildingType.Ancient
			},
			{
				"tall",
				ConfluxBuildingType.Towner
			},
			{
				"tower",
				ConfluxBuildingType.Towner
			}
		};

		public static ConfluxMoonController Instance { get; private set; } = null;


		public void Awake()
		{
			Instance = this;
		}

		public void SetBuildings()
		{
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_040e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_037f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			List<EntranceTeleport> sortedOutdoorEntrances = MultiDungeonGenerator.Instance.SortedOutdoorEntrances;
			for (int i = 0; i < sortedOutdoorEntrances.Count; i++)
			{
				string text = "?";
				if (MultiDungeonGenerator.Instance.LinkedDungeons.TryGetValue(sortedOutdoorEntrances[i].entranceId, out var value))
				{
					if ((Object)(object)((Component)value).transform.parent == (Object)null)
					{
						continue;
					}
					string name = ((Object)((Component)((Component)value).transform.parent).gameObject).name;
					if (name == "MainDungen")
					{
						text = "Main";
					}
					if (name.StartsWith("Dungen"))
					{
						text = name.Substring(6);
					}
				}
				if (!((Object)(object)((Component)sortedOutdoorEntrances[i]).GetComponentInParent<ConfluxBuilding>() != (Object)null))
				{
					continue;
				}
				ConfluxBuilding componentInParent = ((Component)sortedOutdoorEntrances[i]).GetComponentInParent<ConfluxBuilding>();
				if (text == "Main")
				{
					componentInParent.Type = ConfluxBuildingType.Main;
					componentInParent.MainVisuals.SetActive(true);
					componentInParent.FactoryVisuals.SetActive(false);
					componentInParent.ResidentialVisuals.SetActive(false);
					componentInParent.MineshaftVisuals.SetActive(false);
					componentInParent.AncientVisuals.SetActive(false);
					componentInParent.TowerVisuals.SetActive(false);
					((Component)componentInParent).transform.position = MainBuildingPosition.position;
					((Component)componentInParent).transform.rotation = MainBuildingPosition.rotation;
					ConfluxMod.Logger.LogInfo((object)$"Setting Main Building at {((Component)componentInParent).transform.position}");
				}
				else
				{
					if ((Object)(object)value != (Object)null && (Object)(object)value.DungeonFlow != (Object)null)
					{
						componentInParent.Type = DetermineBuildingType(value);
					}
					else
					{
						ManualLogSource logger = ConfluxMod.Logger;
						string[] obj = new string[7]
						{
							"Could not determine building type for building",
							$" {((Object)componentInParent).name} at position {((Component)componentInParent).transform.position}.",
							" (",
							((value != null) ? ((Object)value).name : null) ?? "no linked dungeon",
							") (flow: ",
							null,
							null
						};
						object obj2;
						if (value == null)
						{
							obj2 = null;
						}
						else
						{
							DungeonFlow dungeonFlow = value.DungeonFlow;
							obj2 = ((dungeonFlow != null) ? ((Object)dungeonFlow).name : null);
						}
						if (obj2 == null)
						{
							obj2 = "no flow";
						}
						obj[5] = (string)obj2;
						obj[6] = ")";
						logger.LogWarning((object)string.Concat(obj));
					}
					componentInParent.FactoryVisuals.SetActive(componentInParent.Type == ConfluxBuildingType.Factory);
					componentInParent.ResidentialVisuals.SetActive(componentInParent.Type == ConfluxBuildingType.Residential);
					componentInParent.MineshaftVisuals.SetActive(componentInParent.Type == ConfluxBuildingType.Mineshaft);
					componentInParent.AncientVisuals.SetActive(componentInParent.Type == ConfluxBuildingType.Ancient);
					componentInParent.TowerVisuals.SetActive(componentInParent.Type == ConfluxBuildingType.Towner);
					switch (componentInParent.Type)
					{
					case ConfluxBuildingType.Towner:
						((Component)componentInParent.MainEntrance).transform.parent.localPosition = componentInParent.TowerMainPosition.localPosition;
						break;
					case ConfluxBuildingType.Ancient:
						((Component)componentInParent.MainEntrance).transform.parent.localPosition = componentInParent.AcientMainPosition.localPosition;
						break;
					}
					Transform val = BuildingPositions[0];
					if ((Object)(object)val != (Object)null)
					{
						((Component)componentInParent).transform.position = val.position;
						((Component)componentInParent).transform.rotation = val.rotation;
					}
				}
				componentInParent.letter = text;
				componentInParent.DebugLabel.text = $"{componentInParent.letter}({sortedOutdoorEntrances[i].entranceId})";
				ConfluxMod.Logger.LogInfo((object)$"Setting Building {componentInParent.letter} of type {componentInParent.Type} at {((Component)componentInParent).transform.position} for entrance at position {((Component)sortedOutdoorEntrances[i]).transform.position}");
				if (text != "Main")
				{
					BuildingPositions.RemoveAt(0);
				}
			}
		}

		public static ConfluxBuildingType DetermineBuildingType(Dungeon linkedDungeon)
		{
			object obj;
			if (linkedDungeon == null)
			{
				obj = null;
			}
			else
			{
				DungeonFlow dungeonFlow = linkedDungeon.DungeonFlow;
				obj = ((dungeonFlow != null) ? ((Object)dungeonFlow).name : null);
			}
			if (obj == null)
			{
				return ConfluxBuildingType.Factory;
			}
			string name = ((Object)linkedDungeon.DungeonFlow).name;
			if (ExactFlowMatches.TryGetValue(name, out var value))
			{
				return value;
			}
			string text = name.ToLower();
			foreach (KeyValuePair<string, ConfluxBuildingType> partialStringMatch in PartialStringMatches)
			{
				if (text.Contains(partialStringMatch.Key))
				{
					ConfluxMod.Logger.LogDebug((object)$"Partial match found for flow '{name}': '{partialStringMatch.Key}' -> {partialStringMatch.Value}");
					return partialStringMatch.Value;
				}
			}
			char[] separator = new char[8] { ' ', '_', '-', '.', '(', ')', '[', ']' };
			string[] array = text.Split(separator, StringSplitOptions.RemoveEmptyEntries);
			string[] array2 = array;
			foreach (string text2 in array2)
			{
				if (PartialStringMatches.TryGetValue(text2, out var value2))
				{
					ConfluxMod.Logger.LogDebug((object)$"Word match found for flow '{name}': '{text2}' -> {value2}");
					return value2;
				}
			}
			return ConfluxBuildingType.Factory;
		}

		public void SetScreenTextEmpty()
		{
			((TMP_Text)HUDManager.Instance.loadingText).text = $"Random seed: {StartOfRound.Instance.randomMapSeed}";
		}

		public void SetScreenText(RuntimeDungeon dungeon)
		{
			((TMP_Text)HUDManager.Instance.loadingText).text = $"Random seed ({MultiDungeonGenerator.Instance.currentDungeonIndex + 1}): {dungeon.Generator.Seed}";
			((Behaviour)HUDManager.Instance.loadingDarkenScreen).enabled = true;
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			((NetworkBehaviour)this).__initializeRpcs();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "ConfluxMoonController";
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "NoteBoxz.ConfluxMod";

		public const string PLUGIN_NAME = "ConfluxMod";

		public const string PLUGIN_VERSION = "0.1.8";
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace __GEN
{
	internal class NetworkVariableSerializationHelper
	{
		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeSerialization()
		{
		}
	}
}
namespace NoteBoxz.ConfluxMod.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}