using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using ArtifactOfSharing.Artifact;
using ArtifactOfSharing.Utils;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using R2API;
using R2API.ScriptableObjects;
using R2API.Utils;
using RiskOfOptions;
using RiskOfOptions.OptionConfigs;
using RiskOfOptions.Options;
using RoR2;
using RoR2.Achievements.Artifacts;
using RoR2.ContentManagement;
using RoR2.Networking;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Networking;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("ArtifactOfSharing")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("ArtifactOfSharing")]
[assembly: AssemblyTitle("ArtifactOfSharing")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace ArtifactOfSharing
{
	public class SetInventoryMessage : ArtifactMessageBase
	{
		private Inventory inventory;

		private Dictionary<ItemDef, uint> itemCounts;

		private Dictionary<uint, EquipmentIndex> equipments;

		public SetInventoryMessage()
		{
		}

		public SetInventoryMessage(Inventory inventory, Inventory invToSet)
		{
			this.inventory = inventory;
			itemCounts = invToSet.FilterCountNotZero(ContentManager.itemDefs);
			equipments = EquipmentData(invToSet);
		}

		public static Dictionary<uint, EquipmentIndex> EquipmentData(Inventory invToSet)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<uint, EquipmentIndex> dictionary = new Dictionary<uint, EquipmentIndex>();
			for (uint num = 0u; num < invToSet.GetEquipmentSlotCount(); num++)
			{
				dictionary.Add(num, invToSet.GetEquipment(num).equipmentIndex);
			}
			return dictionary;
		}

		public SetInventoryMessage(Inventory inventory, Dictionary<ItemDef, int> itemCounts, Dictionary<uint, EquipmentIndex> equipments)
		{
			this.inventory = inventory;
			this.itemCounts = itemCounts.ToDictionary((KeyValuePair<ItemDef, int> x) => x.Key, (KeyValuePair<ItemDef, int> x) => (uint)x.Value);
			this.equipments = equipments.ToDictionary((KeyValuePair<uint, EquipmentIndex> x) => x.Key, (KeyValuePair<uint, EquipmentIndex> x) => x.Value);
		}

		public override void Serialize(NetworkWriter writer)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			((MessageBase)this).Serialize(writer);
			writer.Write(((NetworkBehaviour)inventory).netId);
			writer.Write(itemCounts);
			writer.Write(equipments);
		}

		public override void Deserialize(NetworkReader reader)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			((MessageBase)this).Deserialize(reader);
			GameObject obj = Util.FindNetworkObject(reader.ReadNetworkId());
			inventory = ((obj != null) ? obj.GetComponent<Inventory>() : null);
			itemCounts = reader.ReadItemAmounts();
			equipments = reader.ReadEquipmentIndices();
		}

		public override void Handle()
		{
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			base.Handle();
			ItemDef[] itemDefs = ContentManager.itemDefs;
			foreach (ItemDef val in itemDefs)
			{
				int itemCount = inventory.GetItemCount(val);
				int num = (int)(itemCounts.ContainsKey(val) ? itemCounts[val] : 0);
				if (itemCount > num)
				{
					inventory.RemoveItem(val, itemCount - num);
				}
				else if (num > itemCount)
				{
					inventory.GiveItem(val, num - itemCount);
				}
			}
			foreach (KeyValuePair<uint, EquipmentIndex> equipment in equipments)
			{
				inventory.SetEquipmentIndexForSlot(equipment.Value, equipment.Key);
			}
		}
	}
	[RegisterAchievement("ObtainArtifactSharing", "Artifacts.Sharing", null, null)]
	public class ArtifactOfSharingAchievement : BaseObtainArtifactAchievement
	{
		public override ArtifactDef artifactDef => ArtifactBase<ArtifactOfSharing.Artifact.ArtifactOfSharing>.instance.ArtifactDef;
	}
	[BepInPlugin("com.amrothabet.ArtifactOfSharing", "Artifact Of Sharing", "0.0.1")]
	[BepInDependency("com.bepis.r2api", "4.4.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	[R2APISubmoduleDependency(new string[] { "ArtifactCodeAPI", "LanguageAPI" })]
	public class Main : BaseUnityPlugin
	{
		public const string ModGuid = "com.amrothabet.ArtifactOfSharing";

		public const string ModName = "Artifact Of Sharing";

		public const string ModVer = "0.0.1";

		public static AssetBundle MainAssets;

		public List<ArtifactBase> Artifacts = new List<ArtifactBase>();

		public static ManualLogSource ModLogger;

		private void Awake()
		{
			ModLogger = ((BaseUnityPlugin)this).Logger;
			ModLogger.LogInfo((object)"ARTIFACT MAIN");
			LanguageAPI.Add("ACHIEVEMENT_OBTAINARTIFACTSHARING_NAME", "Trial of Sharing");
			LanguageAPI.Add("ACHIEVEMENT_OBTAINARTIFACTSHARING_DESCRIPTION", "Complete the Trial of Sharing.");
			using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("ArtifactOfSharing.artifactofsharingbundle"))
			{
				MainAssets = AssetBundle.LoadFromStream(stream);
			}
			ModLogger.LogInfo((object)"LOADED ASSETS");
			ModSettingsManager.SetModDescription("Adds Artifact of Sharing which swaps players' inventories (items & equipment) every stage");
			ModSettingsManager.SetModIcon(MainAssets.LoadAsset<Sprite>("aosenabled.png"));
			foreach (Type item in from type in Assembly.GetExecutingAssembly().GetTypes()
				where !type.IsAbstract && type.IsSubclassOf(typeof(ArtifactBase))
				select type)
			{
				ArtifactBase artifactBase = (ArtifactBase)Activator.CreateInstance(item);
				if (ValidateArtifact(artifactBase, Artifacts))
				{
					artifactBase.Init(((BaseUnityPlugin)this).Config);
					AddUnlockable(artifactBase.ArtifactDef, artifactBase.ArtifactUnlockableName);
				}
			}
			ModLogger.LogInfo((object)"SETUP ARTIFACT");
		}

		public static void AddUnlockable(ArtifactDef def, string name)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			Sprite achievementIcon = MainAssets.LoadAsset<Sprite>("aosenabled.png");
			UnlockableDef val = ScriptableObject.CreateInstance<UnlockableDef>();
			val.cachedName = "Artifacts." + name;
			val.nameToken = def.nameToken;
			val.achievementIcon = achievementIcon;
			ContentAddition.AddUnlockableDef(val);
			def.unlockableDef = val;
			PickupDef pickupDef = PickupCatalog.GetPickupDef(PickupCatalog.FindPickupIndex(def.artifactIndex));
			if (pickupDef != null)
			{
				pickupDef.unlockableDef = val;
			}
			RuleDef val2 = RuleCatalog.FindRuleDef("Artifacts." + def.cachedName);
			if (val2 == null)
			{
				val2 = new RuleDef("Artifacts." + def.cachedName, def.descriptionToken);
				val2.AddChoice("On", (object)null, false);
				val2.FindChoice("On").requiredUnlockable = val;
				RuleCatalog.AddRule(val2);
			}
			else
			{
				val2.FindChoice("On").requiredUnlockable = val;
			}
		}

		public bool ValidateArtifact(ArtifactBase artifact, List<ArtifactBase> artifactList)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			ModLogger.LogInfo((object)("ValidateArtifact " + artifact.ArtifactName));
			ConfigEntry<bool> obj = ((BaseUnityPlugin)this).Config.Bind<bool>("Artifact: " + artifact.ArtifactName, "Enable Artifact?", true, "Should this artifact appear for selection?");
			ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(obj));
			ModSettingsManager.AddOption((BaseOption)new GenericButtonOption("Force Enable/Disable", "Artifact: " + artifact.ArtifactName, "Enable/Disable the artifact without needing to unlock it by code.", "Toggle", new UnityAction(ToggleUnlock)));
			if (obj.Value)
			{
				artifactList.Add(artifact);
			}
			return obj.Value;
		}

		public UserProfile GetUserProfile()
		{
			LocalUser? obj = ((IEnumerable<LocalUser>)LocalUserManager.readOnlyLocalUsersList).FirstOrDefault((Func<LocalUser, bool>)((LocalUser v) => v != null));
			if (obj == null)
			{
				return null;
			}
			return obj.userProfile;
		}

		private void ToggleUnlock()
		{
			//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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			UserProfile userProfile = GetUserProfile();
			UnlockableDef unlockableDef = ArtifactBase<ArtifactOfSharing.Artifact.ArtifactOfSharing>.instance.ArtifactDef.unlockableDef;
			string achievementName = "ACHIEVEMENT_OBTAINARTIFACTSHARING_NAME";
			AchievementDef val = AchievementManager.achievementDefs.Where((AchievementDef x) => x.nameToken.Equals(achievementName)).FirstOrDefault();
			bool flag = val != null && userProfile.HasAchievement(val.identifier);
			bool num = userProfile.HasUnlockable(unlockableDef);
			PickupIndex val2 = PickupCatalog.FindPickupIndex(ArtifactBase<ArtifactOfSharing.Artifact.ArtifactOfSharing>.instance.ArtifactDef.artifactIndex);
			if (!num)
			{
				if (!flag)
				{
					userProfile.AddAchievement(val.identifier, true);
				}
				userProfile.GrantUnlockable(unlockableDef);
				userProfile.SetPickupDiscovered(val2, true);
				userProfile.RequestEventualSave();
			}
			else
			{
				if (flag)
				{
					userProfile.RevokeAchievement(val.identifier);
				}
				userProfile.RevokeUnlockable(unlockableDef);
				userProfile.SetPickupDiscovered(val2, false);
				userProfile.RequestEventualSave();
			}
		}
	}
}
namespace ArtifactOfSharing.Utils
{
	public static class Extensions
	{
		public static void Write(this NetworkWriter writer, Dictionary<ItemDef, uint> itemCounts)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected I4, but got Unknown
			writer.WritePackedUInt32((uint)itemCounts.Count);
			foreach (KeyValuePair<ItemDef, uint> itemCount in itemCounts)
			{
				writer.WritePackedUInt32((uint)(int)itemCount.Key.itemIndex);
				writer.WritePackedUInt32(itemCount.Value);
			}
		}

		public static void Write(this NetworkWriter writer, Dictionary<uint, EquipmentIndex> equipments)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected I4, but got Unknown
			writer.WritePackedUInt32((uint)equipments.Count);
			foreach (KeyValuePair<uint, EquipmentIndex> equipment in equipments)
			{
				writer.WritePackedUInt32(equipment.Key);
				writer.WritePackedUInt32((uint)(int)equipment.Value);
			}
		}

		public static Dictionary<ItemDef, uint> ReadItemAmounts(this NetworkReader reader)
		{
			Dictionary<ItemDef, uint> dictionary = new Dictionary<ItemDef, uint>();
			uint num = reader.ReadPackedUInt32();
			for (int i = 0; i < num; i++)
			{
				ItemDef itemDef = ItemCatalog.GetItemDef((ItemIndex)reader.ReadPackedUInt32());
				dictionary.Add(itemDef, reader.ReadPackedUInt32());
			}
			return dictionary;
		}

		public static Dictionary<uint, EquipmentIndex> ReadEquipmentIndices(this NetworkReader reader)
		{
			Dictionary<uint, EquipmentIndex> dictionary = new Dictionary<uint, EquipmentIndex>();
			uint num = reader.ReadPackedUInt32();
			for (int i = 0; i < num; i++)
			{
				dictionary.Add(reader.ReadPackedUInt32(), (EquipmentIndex)reader.ReadPackedUInt32());
			}
			return dictionary;
		}

		public static Dictionary<ItemDef, uint> FilterCountNotZero(this Inventory invToSet, ItemDef[] defs)
		{
			Dictionary<ItemDef, uint> dictionary = new Dictionary<ItemDef, uint>();
			foreach (ItemDef val in defs)
			{
				int itemCount = invToSet.GetItemCount(val);
				if (itemCount > 0)
				{
					dictionary.Add(val, (uint)itemCount);
				}
			}
			return dictionary;
		}

		public static T GetField<T>(string fieldName, BindingFlags bindingFlags)
		{
			try
			{
				return (T)(typeof(ServerAuthManager).GetField("fieldName", bindingFlags)?.GetValue(null));
			}
			catch (Exception ex)
			{
				Debug.LogException(ex);
			}
			return default(T);
		}
	}
	public static class NetworkManager
	{
		public static Type[] RegisteredMessages;

		public static void Initialize()
		{
			NetworkManagerSystem.onStartServerGlobal += RegisterMessages;
			NetworkManagerSystem.onStartClientGlobal += RegisterMessages;
			RegisteredMessages = (from x in typeof(ArtifactMessageBase).Assembly.GetTypes()
				where typeof(ArtifactMessageBase).IsAssignableFrom(x) && x != typeof(ArtifactMessageBase)
				select x).ToArray();
		}

		private static void RegisterMessages()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			NetworkServer.RegisterHandler((short)2004, new NetworkMessageDelegate(HandleMessage));
		}

		public static void RegisterMessages(NetworkClient client)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			client.RegisterHandler((short)2004, new NetworkMessageDelegate(HandleMessage));
		}

		private static void HandleMessage(NetworkMessage netmsg)
		{
			ArtifactMessage artifactMessage = netmsg.ReadMessage<ArtifactMessage>();
			if (artifactMessage.message is BroadcastMessage broadcastMessage)
			{
				broadcastMessage.fromConnection = netmsg.conn;
			}
			artifactMessage.message.Handle();
		}

		public static void Send<T>(this NetworkConnection connection, T message) where T : ArtifactMessageBase
		{
			ArtifactMessage artifactMessage = new ArtifactMessage(message);
			connection.Send((short)2004, (MessageBase)(object)artifactMessage);
		}
	}
	public class ArtifactMessageBase : MessageBase
	{
		public virtual void Handle()
		{
		}

		public void SendToServer()
		{
			if (!NetworkServer.active)
			{
				ClientScene.readyConnection.Send(this);
			}
			else
			{
				Handle();
			}
		}

		public void SendToEveryone()
		{
			Handle();
			new BroadcastMessage(this).SendToServer();
		}

		public void SendToAuthority(NetworkIdentity identity)
		{
			if (!Util.HasEffectiveAuthority(identity) && NetworkServer.active)
			{
				identity.clientAuthorityOwner.Send(this);
			}
			else if (!NetworkServer.active)
			{
				new NewAuthMessage(identity, this).SendToServer();
			}
			else
			{
				Handle();
			}
		}

		public void SendToAuthority(NetworkUser user)
		{
			SendToAuthority(((NetworkBehaviour)user).netIdentity);
		}

		public void SendToAuthority(CharacterMaster master)
		{
			SendToAuthority(master.networkIdentity);
		}

		public void SendToAuthority(CharacterBody body)
		{
			SendToAuthority(body.networkIdentity);
		}
	}
	public class BroadcastMessage : ArtifactMessageBase
	{
		public NetworkConnection fromConnection;

		private ArtifactMessageBase message;

		public BroadcastMessage()
		{
		}

		public BroadcastMessage(ArtifactMessageBase artifactMessageBase)
		{
			message = artifactMessageBase;
		}

		public override void Handle()
		{
			base.Handle();
			foreach (NetworkConnection connection in NetworkServer.connections)
			{
				if (connection != fromConnection && connection.isConnected)
				{
					connection.Send(message);
				}
			}
			message.Handle();
		}

		public override void Deserialize(NetworkReader reader)
		{
			((MessageBase)this).Deserialize(reader);
			message = reader.ReadMessage<ArtifactMessage>().message;
		}

		public override void Serialize(NetworkWriter writer)
		{
			((MessageBase)this).Serialize(writer);
			writer.Write((MessageBase)(object)new ArtifactMessage(message));
		}
	}
	public class NewAuthMessage : ArtifactMessageBase
	{
		private ArtifactMessageBase message;

		private NetworkIdentity target;

		public NewAuthMessage()
		{
		}

		public NewAuthMessage(NetworkIdentity identity, ArtifactMessageBase artifactMessageBase)
		{
			target = identity;
			message = artifactMessageBase;
		}

		public override void Handle()
		{
			base.Handle();
			message.SendToAuthority(target);
		}

		public override void Deserialize(NetworkReader reader)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			((MessageBase)this).Deserialize(reader);
			GameObject val = Util.FindNetworkObject(reader.ReadNetworkId());
			if (Object.op_Implicit((Object)(object)val))
			{
				target = val.GetComponent<NetworkIdentity>();
			}
			message = reader.ReadMessage<ArtifactMessage>().message;
		}

		public override void Serialize(NetworkWriter writer)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			((MessageBase)this).Serialize(writer);
			writer.Write(target.netId);
			writer.Write((MessageBase)(object)new ArtifactMessage(message));
		}
	}
	internal class ArtifactMessage : MessageBase
	{
		public ArtifactMessageBase message;

		public uint Type;

		public ArtifactMessage()
		{
		}

		public ArtifactMessage(ArtifactMessageBase artifactMessageBase)
		{
			message = artifactMessageBase;
			Type = (uint)Array.IndexOf(NetworkManager.RegisteredMessages, ((object)message).GetType());
		}

		public override void Serialize(NetworkWriter writer)
		{
			((MessageBase)this).Serialize(writer);
			writer.WritePackedUInt32(Type);
			writer.Write((MessageBase)(object)message);
		}

		public override void Deserialize(NetworkReader reader)
		{
			((MessageBase)this).Deserialize(reader);
			Type = reader.ReadPackedUInt32();
			ArtifactMessageBase artifactMessageBase = (ArtifactMessageBase)Activator.CreateInstance(NetworkManager.RegisteredMessages[Type]);
			((MessageBase)artifactMessageBase).Deserialize(reader);
			message = artifactMessageBase;
		}
	}
}
namespace ArtifactOfSharing.Artifact
{
	public abstract class ArtifactBase<T> : ArtifactBase where T : ArtifactBase<T>
	{
		public static T instance { get; private set; }

		public ArtifactBase()
		{
			if (instance != null)
			{
				throw new InvalidOperationException("Singleton class \"" + typeof(T).Name + "\" inheriting ArtifactBase was instantiated twice");
			}
			instance = this as T;
		}
	}
	public abstract class ArtifactBase
	{
		public ArtifactCode ArtifactCode;

		public ArtifactDef ArtifactDef;

		public abstract string ArtifactName { get; }

		public abstract string ArtifactLangTokenName { get; }

		public abstract string ArtifactUnlockableName { get; }

		public abstract string ArtifactDescription { get; }

		public abstract Sprite ArtifactEnabledIcon { get; }

		public abstract Sprite ArtifactDisabledIcon { get; }

		public bool ArtifactEnabled => RunArtifactManager.instance.IsArtifactEnabled(ArtifactDef);

		public abstract void Init(ConfigFile config);

		protected void CreateLang()
		{
			LanguageAPI.Add("ARTIFACT_" + ArtifactLangTokenName + "_NAME", ArtifactName);
			LanguageAPI.Add("ARTIFACT_" + ArtifactLangTokenName + "_DESCRIPTION", ArtifactDescription);
		}

		protected void CreateArtifact()
		{
			ArtifactDef = ScriptableObject.CreateInstance<ArtifactDef>();
			ArtifactDef.cachedName = "ARTIFACT_" + ArtifactLangTokenName;
			ArtifactDef.nameToken = "ARTIFACT_" + ArtifactLangTokenName + "_NAME";
			ArtifactDef.descriptionToken = "ARTIFACT_" + ArtifactLangTokenName + "_DESCRIPTION";
			ArtifactDef.smallIconSelectedSprite = ArtifactEnabledIcon;
			ArtifactDef.smallIconDeselectedSprite = ArtifactDisabledIcon;
			ContentAddition.AddArtifactDef(ArtifactDef);
		}

		public abstract void Hooks();
	}
	internal enum SharingType
	{
		Swap_Full_Inventories,
		Swap_Partial_Inventories
	}
	internal class ArtifactOfSharing : ArtifactBase<ArtifactOfSharing>
	{
		public static ConfigEntry<bool> ChangeSinglePlayerInventory;

		public static ConfigEntry<SharingType> MultiPlayerSharingType;

		public static ConfigEntry<int> Threshold;

		public HashSet<NetworkUser> users;

		public override string ArtifactName => "Artifact of Sharing";

		public override string ArtifactUnlockableName => "Sharing";

		public override string ArtifactLangTokenName => "ARTIFACT_OF_SHARING";

		public override string ArtifactDescription => "When enabled, swaps players' equipment and items every stage among themselves.";

		public override Sprite ArtifactEnabledIcon => Main.MainAssets.LoadAsset<Sprite>("aosenabled.png");

		public override Sprite ArtifactDisabledIcon => Main.MainAssets.LoadAsset<Sprite>("aosdisabled.png");

		public override void Init(ConfigFile config)
		{
			Main.ModLogger.LogInfo((object)"INITIALIZING ARTIFACT");
			users = new HashSet<NetworkUser>();
			CreateConfig(config);
			CreateLang();
			CreateArtifact();
			CreateCode();
			Hooks();
		}

		private void CreateCode()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			ArtifactCode = ScriptableObject.CreateInstance<ArtifactCode>();
			ArtifactCode.topRow = new Vector3Int(7, 5, 7);
			ArtifactCode.middleRow = new Vector3Int(1, 7, 1);
			ArtifactCode.bottomRow = new Vector3Int(3, 5, 3);
			ArtifactCodeAPI.AddCode(ArtifactDef, ArtifactCode);
		}

		private void CreateConfig(ConfigFile config)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			ChangeSinglePlayerInventory = config.Bind<bool>("Artifact: " + ArtifactName, "Customize single player items", false, "Customize player's items if only 1 player?");
			MultiPlayerSharingType = config.Bind<SharingType>("Artifact: " + ArtifactName, "Multi-player sharing method", SharingType.Swap_Full_Inventories, "Sharing method can either be set to partial inventory sharing or full inventory sharing.\n\nSwap Partial Inventories: Partial Inventory Sharing works by rolling a chance roll for every item and if the roll exceeds the threshold set, the item will be moved to the next player in the list.\n\nSwap Full Inventories: Full inventory sharing works by passing on the player's entire inventory (items + equipment) over to the next player in the list.");
			Threshold = config.Bind<int>("Artifact: " + ArtifactName, "Partial Sharing Threshold", 50, "Threshold needed to exceed in order to shift item over to the next player");
			ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(ChangeSinglePlayerInventory));
			ModSettingsManager.AddOption((BaseOption)new ChoiceOption((ConfigEntryBase)(object)MultiPlayerSharingType));
			ModSettingsManager.AddOption((BaseOption)new IntSliderOption(Threshold, new IntSliderConfig
			{
				min = 1,
				max = 99,
				checkIfDisabled = new IsDisabledDelegate(IsThresholdDisabled),
				formatString = "{0}%"
			}));
		}

		private bool IsThresholdDisabled()
		{
			return MultiPlayerSharingType.Value != SharingType.Swap_Partial_Inventories;
		}

		public override void Hooks()
		{
			Stage.onServerStageBegin += onServerStageBegin;
		}

		private void onServerStageBegin(Stage stage)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Invalid comparison between Unknown and I4
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_04d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04da: Unknown result type (might be due to invalid IL or missing references)
			//IL_04de: Unknown result type (might be due to invalid IL or missing references)
			//IL_050a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0542: Unknown result type (might be due to invalid IL or missing references)
			//IL_0547: Unknown result type (might be due to invalid IL or missing references)
			//IL_054c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0553: Unknown result type (might be due to invalid IL or missing references)
			//IL_066c: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkServer.active || !base.ArtifactEnabled)
			{
				return;
			}
			Main.ModLogger.LogInfo((object)("SERVER STAGE BEGAN: " + ((object)stage).ToString() + " - " + ((object)stage.sceneDef).ToString()));
			SceneDef sceneDefForCurrentScene = SceneCatalog.GetSceneDefForCurrentScene();
			if (!Object.op_Implicit((Object)(object)sceneDefForCurrentScene) || sceneDefForCurrentScene.isFinalStage || (int)sceneDefForCurrentScene.sceneType != 1 || Run.instance.stageClearCount <= 0)
			{
				return;
			}
			List<NetworkUser> instancesList = NetworkUser.instancesList;
			if (instancesList.Count > 1)
			{
				List<Inventory> list = new List<Inventory>();
				foreach (NetworkUser item in instancesList)
				{
					if (Object.op_Implicit((Object)(object)item.master))
					{
						Inventory inventory = item.master.inventory;
						Inventory val = new Inventory();
						val.CopyEquipmentFrom(inventory);
						val.CopyItemsFrom(inventory);
						list.Add(val);
					}
				}
				if (MultiPlayerSharingType.Value != SharingType.Swap_Partial_Inventories)
				{
					int num = 0;
					{
						foreach (NetworkUser item2 in instancesList)
						{
							if (!Object.op_Implicit((Object)(object)item2.master))
							{
								num++;
								continue;
							}
							int index = ((num != instancesList.Count - 1) ? (num + 1) : 0);
							new SetInventoryMessage(item2.master.inventory, list[index]).SendToServer();
							num++;
						}
						return;
					}
				}
				Dictionary<NetworkUser, Dictionary<ItemDef, int>> dictionary = new Dictionary<NetworkUser, Dictionary<ItemDef, int>>();
				Dictionary<NetworkUser, Dictionary<uint, EquipmentIndex>> dictionary2 = new Dictionary<NetworkUser, Dictionary<uint, EquipmentIndex>>();
				int num2 = Math.Max(Math.Min(Threshold.Value, 99), 1);
				for (int i = 0; i < instancesList.Count; i++)
				{
					NetworkUser val2 = instancesList[i];
					if ((Object)(object)val2.master == (Object)null)
					{
						continue;
					}
					int index2 = ((i != instancesList.Count - 1) ? (i + 1) : 0);
					Dictionary<ItemDef, int> dictionary3 = new Dictionary<ItemDef, int>();
					Inventory invToSet = list[index2];
					Dictionary<ItemDef, uint> dictionary4 = invToSet.FilterCountNotZero(ContentManager.itemDefs);
					foreach (ItemDef item3 in new List<ItemDef>(dictionary4.Keys))
					{
						uint num3 = dictionary4[item3];
						int num4 = 0;
						for (int j = 0; j < num3; j++)
						{
							if (Random.Range(1, 99) > num2)
							{
								num4++;
							}
						}
						dictionary3[item3] = num4;
					}
					dictionary4 = dictionary4.Where((KeyValuePair<ItemDef, uint> keyPair) => keyPair.Value != 0).ToDictionary((KeyValuePair<ItemDef, uint> x) => x.Key, (KeyValuePair<ItemDef, uint> x) => x.Value);
					dictionary.Add(val2, dictionary3);
					dictionary2.Add(val2, SetInventoryMessage.EquipmentData(invToSet));
				}
				for (int k = 0; k < dictionary.Count; k++)
				{
					NetworkUser val3 = instancesList[k];
					if ((Object)(object)val3.master == (Object)null)
					{
						continue;
					}
					int index3 = ((k == 0) ? (instancesList.Count - 1) : (k - 1));
					Dictionary<ItemDef, int> dictionary5 = dictionary[instancesList[index3]];
					Dictionary<ItemDef, int> dictionary6 = dictionary[instancesList[k]];
					Dictionary<ItemDef, uint> dictionary7 = list[k].FilterCountNotZero(ContentManager.itemDefs);
					List<ItemDef> list2 = new List<ItemDef>(dictionary7.Keys);
					list2.AddRange(dictionary6.Keys);
					Dictionary<ItemDef, int> dictionary8 = new Dictionary<ItemDef, int>();
					foreach (ItemDef item4 in list2.Distinct())
					{
						uint num5 = (dictionary7.ContainsKey(item4) ? dictionary7[item4] : 0u);
						int num6 = (dictionary5.ContainsKey(item4) ? dictionary5[item4] : 0);
						int num7 = (dictionary6.ContainsKey(item4) ? dictionary6[item4] : 0);
						dictionary8.Add(item4, (int)num5 - num6 + num7);
					}
					new SetInventoryMessage(val3.master.inventory, dictionary8, dictionary2[val3]).SendToServer();
				}
			}
			else
			{
				if (instancesList.Count != 1 || !ChangeSinglePlayerInventory.Value)
				{
					return;
				}
				NetworkUser val4 = instancesList.First();
				if (!Object.op_Implicit((Object)(object)val4.master))
				{
					return;
				}
				Inventory inventory2 = val4.master.inventory;
				int equipmentSlotCount = inventory2.GetEquipmentSlotCount();
				Dictionary<ItemTier, int> dictionary9 = new Dictionary<ItemTier, int>();
				foreach (ItemTier value in Enum.GetValues(typeof(ItemTier)))
				{
					dictionary9[value] = inventory2.GetTotalItemCountOfTier(value);
				}
				new Inventory();
				Dictionary<uint, EquipmentIndex> randomEquipment = GetRandomEquipment(inventory2, equipmentSlotCount);
				Dictionary<ItemDef, int> dictionary10 = new Dictionary<ItemDef, int>();
				foreach (ItemTier value2 in Enum.GetValues(typeof(ItemTier)))
				{
					foreach (KeyValuePair<ItemDef, int> randomItem in GetRandomItems(dictionary9[value2], value2))
					{
						dictionary10.Add(randomItem.Key, randomItem.Value);
					}
				}
				ItemDef[] itemDefs = ContentManager.itemDefs;
				foreach (ItemDef val7 in itemDefs)
				{
					int itemCount = val4.master.inventory.GetItemCount(val7);
					int num8 = (dictionary10.ContainsKey(val7) ? dictionary10[val7] : 0);
					if (itemCount > num8)
					{
						val4.master.inventory.RemoveItem(val7, itemCount - num8);
					}
					else if (num8 > itemCount)
					{
						val4.master.inventory.GiveItem(val7, num8 - itemCount);
					}
				}
				foreach (KeyValuePair<uint, EquipmentIndex> item5 in randomEquipment)
				{
					val4.master.inventory.SetEquipmentIndexForSlot(item5.Value, item5.Key);
				}
			}
		}

		public Dictionary<uint, EquipmentIndex> GetRandomEquipment(Inventory playerInventory, int count)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<uint, EquipmentIndex> dictionary = new Dictionary<uint, EquipmentIndex>();
			if (count < 1)
			{
				return dictionary;
			}
			List<EquipmentDef> list = new List<EquipmentDef>(ContentManager.equipmentDefs);
			for (uint num = 0u; num < count; num++)
			{
				if ((int)playerInventory.GetEquipment(num).equipmentIndex != -1)
				{
					int index = Random.Range(0, list.Count - 1);
					EquipmentDef val = list[index];
					dictionary.Add(num, val.equipmentIndex);
					list.RemoveAt(index);
				}
			}
			return dictionary;
		}

		public Dictionary<ItemDef, int> GetRandomItems(int count, ItemTier tier)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<ItemDef, int> dictionary = new Dictionary<ItemDef, int>();
			for (int i = 0; i < count; i++)
			{
				List<ItemDef> list = FilterTierItems(ContentManager.itemDefs, tier);
				ItemDef val = list[Random.Range(0, list.Count - 1)];
				if (!((Object)(object)val == (Object)null))
				{
					if (dictionary.ContainsKey(val))
					{
						dictionary[val]++;
					}
					else
					{
						dictionary.Add(val, 1);
					}
				}
			}
			return dictionary;
		}

		private List<ItemDef> FilterTierItems(ItemDef[] itemDefs, ItemTier tier)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			List<ItemDef> list = new List<ItemDef>();
			foreach (ItemDef val in itemDefs)
			{
				if (val.tier == tier)
				{
					list.Add(val);
				}
			}
			return list;
		}
	}
}