using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Dissonance;
using GameNetcodeStuff;
using HarmonyLib;
using JigglePhysics;
using LethalConfig;
using LethalConfig.ConfigItems;
using Microsoft.CodeAnalysis;
using ModelReplacement;
using Unity.Netcode;
using UnityEngine;
using ZinthosReplacement.NetcodePatcher;

[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: AssemblyCompany("ZinthosReplacement")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("ZinthosReplacement")]
[assembly: AssemblyTitle("ZinthosReplacement")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: NetcodePatchedAssembly]
internal class <Module>
{
	static <Module>()
	{
	}
}
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;
		}
	}
}
namespace ZinthosReplacement
{
	public class MRZINTHOS : BodyReplacementBase
	{
		public enum SweaterColors
		{
			Red,
			Orange,
			Yellow,
			Lime,
			Green,
			LightBlue,
			Blue,
			Purple,
			Pink,
			Brown,
			Black,
			White
		}

		private HashSet<int> allBlendShapes = new HashSet<int>();

		private PlayerMicVolume playerMicVolume;

		private int danceNumber = 0;

		private int previousDanceNumber = 0;

		private SkinnedMeshRenderer body;

		private SkinnedMeshRenderer collar;

		private SkinnedMeshRenderer sweater;

		private JiggleRigBuilder chain;

		internal bool TestVariable = false;

		private static readonly Dictionary<int, (int, float)[]> expressions = new Dictionary<int, (int, float)[]>
		{
			{
				0,
				Array.Empty<(int, float)>()
			},
			{
				1,
				new(int, float)[2]
				{
					(115, 100f),
					(118, 63.4f)
				}
			},
			{
				2,
				new(int, float)[1] { (81, 100f) }
			},
			{
				3,
				new(int, float)[2]
				{
					(105, 100f),
					(116, 59.6f)
				}
			},
			{
				4,
				new(int, float)[1] { (112, 100f) }
			},
			{
				5,
				new(int, float)[2]
				{
					(120, 100f),
					(109, 40.6f)
				}
			},
			{
				6,
				new(int, float)[2]
				{
					(112, 47f),
					(115, 100f)
				}
			},
			{
				7,
				Array.Empty<(int, float)>()
			},
			{
				8,
				new(int, float)[1] { (110, 100f) }
			},
			{
				9,
				new(int, float)[1] { (106, 100f) }
			},
			{
				1010,
				new(int, float)[1] { (115, 100f) }
			}
		};

		protected override void Awake()
		{
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			((BodyReplacementBase)this).Awake();
			body = ((Component)base.replacementModel.transform.Find("Body")).GetComponent<SkinnedMeshRenderer>();
			collar = ((Component)base.replacementModel.transform.Find("Outfit - Accesorries")).GetComponent<SkinnedMeshRenderer>();
			sweater = ((Component)base.replacementModel.transform.Find("Outfit - Sweater")).GetComponent<SkinnedMeshRenderer>();
			chain = ((Component)base.replacementModel.transform.Find("Armature/Hips/spine/chest/Chain")).GetComponent<JiggleRigBuilder>();
			playerMicVolume = base.replacementModel.AddComponent<PlayerMicVolume>();
			playerMicVolume.controller = ((BodyReplacementBase)this).controller;
			playerMicVolume.localPlayer = ((NetworkBehaviour)((BodyReplacementBase)this).controller).IsLocalPlayer;
			if (((BodyReplacementBase)this).controller.playerClientId == GameNetworkManager.Instance.localPlayerController.playerClientId)
			{
				ChangeAllClothes(Plugin.enableSweater.Value, Plugin.enableCollar.Value, Plugin.sweaterColor.Value, sendToNetwork: false);
			}
			else if (Plugin.AllPlayersLoaded)
			{
				ZinNetworking.Instance.RequestClothesFromPlayerServerRpc(((BodyReplacementBase)this).controller.actualClientId);
			}
			foreach (KeyValuePair<int, (int, float)[]> expression in expressions)
			{
				(int, float)[] value = expression.Value;
				for (int i = 0; i < value.Length; i++)
				{
					(int, float) tuple = value[i];
					if (!allBlendShapes.Contains(tuple.Item1))
					{
						allBlendShapes.Add(tuple.Item1);
					}
				}
			}
		}

		protected void Update()
		{
			previousDanceNumber = danceNumber;
			danceNumber = ((BodyReplacementBase)this).controller.playerBodyAnimator.GetInteger("emoteNumber");
			if (previousDanceNumber != danceNumber)
			{
				OnEmoteChange(danceNumber);
			}
			if ((Object)(object)playerMicVolume != (Object)null)
			{
				body.SetBlendShapeWeight(0, playerMicVolume.detectedVolumeAmplitude * 75f);
			}
		}

		internal void ChangeAllClothes(bool sweaterActive, bool collarActive, SweaterColors sweaterColor, bool sendToNetwork = true)
		{
			ChangeSweater(sweaterActive);
			ChangeCollar(collarActive);
			ChangeSweaterColor(sweaterColor);
			if (sendToNetwork)
			{
				ZinNetworking.Instance.SendToAllPlayersServerRpc(ZinNetworking.Instance.GetLocalPlayerID(), sweaterActive, collarActive, sweaterColor);
			}
		}

		internal void ChangeSweater(bool sweaterActive)
		{
			if (sweaterActive)
			{
				collar.SetBlendShapeWeight(3, 100f);
				body.SetBlendShapeWeight(99, 100f);
				body.SetBlendShapeWeight(101, 100f);
			}
			else
			{
				collar.SetBlendShapeWeight(3, 0f);
				body.SetBlendShapeWeight(99, 0f);
				body.SetBlendShapeWeight(101, 0f);
			}
			((Component)sweater).gameObject.SetActive(sweaterActive);
		}

		internal void ChangeCollar(bool collarActive)
		{
			if (collarActive)
			{
				foreach (Collider collider in chain.colliders)
				{
					collider.enabled = true;
				}
				((Behaviour)chain).enabled = true;
				collar.SetBlendShapeWeight(2, 0f);
				return;
			}
			((Behaviour)chain).enabled = false;
			foreach (Collider collider2 in chain.colliders)
			{
				collider2.enabled = false;
			}
			collar.SetBlendShapeWeight(2, 100f);
		}

		protected override void OnDeath()
		{
			SkinnedMeshRenderer component = ((Component)base.replacementDeadBody.transform.Find("Body")).GetComponent<SkinnedMeshRenderer>();
			component.SetBlendShapeWeight(107, 100f);
			component.SetBlendShapeWeight(116, 45.3f);
		}

		protected void OnEmoteChange(int emoteId)
		{
			if (expressions.TryGetValue(emoteId, out (int, float)[] value))
			{
				ChangeExpression(value);
			}
			else
			{
				ChangeExpression(expressions[0]);
			}
		}

		protected void ChangeExpression((int, float)[] blendShapes)
		{
			HashSet<int> hashSet = new HashSet<int>(blendShapes.Length);
			for (int i = 0; i < blendShapes.Length; i++)
			{
				hashSet.Add(blendShapes[i].Item1);
				((MonoBehaviour)this).StartCoroutine(FadeToBlendShape(blendShapes[i].Item1, blendShapes[i].Item2, body));
			}
			foreach (int allBlendShape in allBlendShapes)
			{
				if (!hashSet.Contains(allBlendShape))
				{
					((MonoBehaviour)this).StartCoroutine(FadeToBlendShape(allBlendShape, 0f, body));
				}
			}
		}

		private IEnumerator FadeToBlendShape(int index, float value, SkinnedMeshRenderer skinnedMeshRenderer)
		{
			float startValue = skinnedMeshRenderer.GetBlendShapeWeight(index);
			if (startValue != value)
			{
				float timeElapsed = 0f;
				float duration = 0.1f;
				while (timeElapsed < duration)
				{
					skinnedMeshRenderer.SetBlendShapeWeight(index, Mathf.Lerp(startValue, value, timeElapsed / duration));
					timeElapsed += Time.deltaTime;
					yield return null;
				}
				skinnedMeshRenderer.SetBlendShapeWeight(index, value);
			}
		}

		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Zinthos";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		internal void ChangeSweaterColor(SweaterColors value)
		{
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			Color color = default(Color);
			switch (value)
			{
			case SweaterColors.Red:
				((Color)(ref color))..ctor(0.5f, 0.002358496f, 0.002358496f);
				break;
			case SweaterColors.Orange:
				((Color)(ref color))..ctor(0.679f, 0.3478743f, 0.15617f);
				break;
			case SweaterColors.Yellow:
				((Color)(ref color))..ctor(0.6603774f, 0.5796978f, 0f);
				break;
			case SweaterColors.Lime:
				((Color)(ref color))..ctor(0.4266146f, 0.5754716f, 0f);
				break;
			case SweaterColors.Green:
				((Color)(ref color))..ctor(0.009288041f, 0.4622641f, 0f);
				break;
			case SweaterColors.LightBlue:
				((Color)(ref color))..ctor(0.5868636f, 0.6702911f, 0.7924528f);
				break;
			case SweaterColors.Blue:
				((Color)(ref color))..ctor(0.05f, 0.05f, 0.482f);
				break;
			case SweaterColors.Purple:
				((Color)(ref color))..ctor(0.3197155f, 0f, 0.5f);
				break;
			case SweaterColors.Pink:
				((Color)(ref color))..ctor(0.6980392f, 0.3921568f, 0.5580437f);
				break;
			case SweaterColors.Brown:
				((Color)(ref color))..ctor(0.3568628f, 0.1654893f, 0.08627448f);
				break;
			case SweaterColors.Black:
				((Color)(ref color))..ctor(0.133f, 0.121f, 0.118f);
				break;
			case SweaterColors.White:
				((Color)(ref color))..ctor(0.75f, 0.75f, 0.75f);
				break;
			default:
				((Color)(ref color))..ctor(1f, 0f, 1f);
				break;
			}
			((Renderer)sweater).material.color = color;
		}
	}
	internal class ConfigManager
	{
		private static bool SettingChanged;

		public static void lethalConfigSetup()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			LethalConfigManager.SkipAutoGen();
			BoolCheckBoxConfigItem val = new BoolCheckBoxConfigItem(Plugin.enableSweater, false);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val);
			BoolCheckBoxConfigItem val2 = new BoolCheckBoxConfigItem(Plugin.enableCollar, false);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val2);
			EnumDropDownConfigItem<MRZINTHOS.SweaterColors> val3 = new EnumDropDownConfigItem<MRZINTHOS.SweaterColors>(Plugin.sweaterColor, false);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val3);
		}

		public static void configEventListeners()
		{
			Plugin.enableSweater.SettingChanged += delegate
			{
				if (!SettingChanged)
				{
					((MonoBehaviour)StartOfRound.Instance).StartCoroutine(WaitPlease());
				}
			};
			Plugin.enableCollar.SettingChanged += delegate
			{
				if (!SettingChanged)
				{
					((MonoBehaviour)StartOfRound.Instance).StartCoroutine(WaitPlease());
				}
			};
			Plugin.sweaterColor.SettingChanged += delegate
			{
				if (!SettingChanged)
				{
					((MonoBehaviour)StartOfRound.Instance).StartCoroutine(WaitPlease());
				}
			};
		}

		private static IEnumerator WaitPlease()
		{
			if (SettingChanged)
			{
				yield break;
			}
			SettingChanged = true;
			yield return (object)new WaitForSeconds(0.1f);
			if (!((Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)null))
			{
				MRZINTHOS zinthos = ((Component)GameNetworkManager.Instance.localPlayerController).gameObject.GetComponent<MRZINTHOS>();
				if ((Object)(object)zinthos != (Object)null)
				{
					zinthos.ChangeAllClothes(Plugin.enableSweater.Value, Plugin.enableCollar.Value, Plugin.sweaterColor.Value);
				}
				yield return (object)new WaitForSeconds(0.1f);
				SettingChanged = false;
			}
		}
	}
	public class PlayerMicVolume : MonoBehaviour
	{
		public bool useDissonanceForMicDetection = true;

		[Space(3f)]
		private DissonanceComms comms;

		public float detectedVolumeAmplitude;

		public float MicLoudness;

		private AudioClip _clipRecord;

		private int _sampleWindow = 128;

		public PlayerControllerB controller;

		public bool localPlayer = false;

		private float LevelMax()
		{
			float num = 0f;
			float[] array = new float[_sampleWindow];
			int num2 = Microphone.GetPosition(IngamePlayerSettings.Instance.unsavedSettings.micDevice) - (_sampleWindow + 1);
			if (num2 < 0)
			{
				return 0f;
			}
			_clipRecord.GetData(array, num2);
			for (int i = 0; i < _sampleWindow; i++)
			{
				float num3 = array[i] * array[i];
				if (num < num3)
				{
					num = num3;
				}
			}
			return num;
		}

		private void Update()
		{
			if ((Object)(object)controller != (Object)null && controller.voicePlayerState == null)
			{
				detectedVolumeAmplitude = 0f;
				if (!IngamePlayerSettings.Instance.unsavedSettings.micEnabled || (IngamePlayerSettings.Instance.settings.pushToTalk && !IngamePlayerSettings.Instance.playerInput.actions.FindAction("VoiceButton", false).IsPressed() && !GameNetworkManager.Instance.localPlayerController.speakingToWalkieTalkie))
				{
					return;
				}
				if (useDissonanceForMicDetection && (Object)(object)NetworkManager.Singleton != (Object)null)
				{
					if ((Object)(object)comms == (Object)null)
					{
						comms = Object.FindObjectOfType<DissonanceComms>();
					}
					detectedVolumeAmplitude = Mathf.Clamp(comms.FindPlayer(comms.LocalPlayerName).Amplitude * 35f, 0f, 1f);
				}
				else
				{
					detectedVolumeAmplitude = Mathf.Clamp(LevelMax() * 300f, 0f, 1f);
				}
				if (detectedVolumeAmplitude < 0.25f)
				{
					detectedVolumeAmplitude = 0f;
				}
			}
			else
			{
				detectedVolumeAmplitude = Mathf.Clamp(controller.voicePlayerState.Amplitude * 35f, 0f, 1f);
			}
		}
	}
	[BepInPlugin("julian0555.zinthos", "Zinthos Scavenger", "1.0.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public static ConfigFile config;

		public static ManualLogSource logger;

		public static bool AllPlayersLoaded;

		public static ConfigEntry<bool> enableModelForAllSuits { get; private set; }

		public static ConfigEntry<bool> enableModelAsDefault { get; private set; }

		public static ConfigEntry<string> suitNamesToEnableModel { get; private set; }

		public static ConfigEntry<bool> enableSweater { get; private set; }

		public static ConfigEntry<bool> enableCollar { get; private set; }

		public static ConfigEntry<MRZINTHOS.SweaterColors> sweaterColor { get; private set; }

		private static void InitConfig()
		{
			enableModelForAllSuits = config.Bind<bool>("Suits to Replace Settings", "Enable Model for all Suits", false, "Enable to model replace every suit. Set to false to specify suits");
			enableModelAsDefault = config.Bind<bool>("Suits to Replace Settings", "Enable Model as default", false, "Enable to model replace every suit that hasn't been otherwise registered.");
			suitNamesToEnableModel = config.Bind<string>("Suits to Replace Settings", "Suits to enable Model for", "Zinthos", "Enter a comma separated list of suit names.(Additionally, [Green suit,Pajama suit,Hazard suit])");
			enableSweater = config.Bind<bool>("Zinthos Customization (Self Only)", "Enable Sweater", false, "Enables sweater on local player's Zinthos model.");
			enableCollar = config.Bind<bool>("Zinthos Customization (Self Only)", "Enable Collar", false, "Enables collar on local player's Zinthos model.");
			sweaterColor = config.Bind<MRZINTHOS.SweaterColors>("Zinthos Customization (Self Only)", "Sweater Color", MRZINTHOS.SweaterColors.Red, "Sets the color used on local player's sweater.");
			if (Chainloader.PluginInfos.ContainsKey("ainavt.lc.lethalconfig"))
			{
				ConfigManager.lethalConfigSetup();
				ConfigManager.configEventListeners();
			}
		}

		private void Awake()
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			config = ((BaseUnityPlugin)this).Config;
			InitConfig();
			Assets.PopulateAssets();
			if (enableModelForAllSuits.Value)
			{
				ModelReplacementAPI.RegisterModelReplacementOverride(typeof(MRZINTHOS));
			}
			if (enableModelAsDefault.Value)
			{
				ModelReplacementAPI.RegisterModelReplacementDefault(typeof(MRZINTHOS));
			}
			string[] array = suitNamesToEnableModel.Value.Split(',');
			string[] array2 = array;
			foreach (string text in array2)
			{
				ModelReplacementAPI.RegisterSuitModelReplacement(text, typeof(MRZINTHOS));
			}
			Harmony val = new Harmony("julian0555.zinthos");
			val.PatchAll();
			NetcodePatcher();
			logger = ((BaseUnityPlugin)this).Logger;
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin julian0555.zinthos is loaded!");
		}

		private static 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);
					}
				}
			}
		}

		internal bool IsPlayerZinthos(PlayerControllerB playerController)
		{
			if ((Object)(object)playerController == (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)playerController).gameObject.GetComponent<MRZINTHOS>() == (Object)null)
			{
				return false;
			}
			return true;
		}
	}
	public static class Assets
	{
		public static string mainAssetBundleName = "zinthos";

		public static AssetBundle MainAssetBundle = null;

		private static string GetAssemblyName()
		{
			return Assembly.GetExecutingAssembly().GetName().Name.Replace(" ", "_");
		}

		public static void PopulateAssets()
		{
			if ((Object)(object)MainAssetBundle == (Object)null)
			{
				Console.WriteLine(GetAssemblyName() + "." + mainAssetBundleName);
				using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(GetAssemblyName() + "." + mainAssetBundleName);
				MainAssetBundle = AssetBundle.LoadFromStream(stream);
			}
		}
	}
	[HarmonyPatch]
	public class NetworkObjectManager
	{
		private static GameObject networkPrefab;

		[HarmonyPostfix]
		[HarmonyPatch(typeof(GameNetworkManager), "Start")]
		public static void Init()
		{
			if (!((Object)(object)networkPrefab != (Object)null))
			{
				networkPrefab = Assets.MainAssetBundle.LoadAsset<GameObject>("ZinNetwork");
				networkPrefab.AddComponent<ZinNetworking>();
				Plugin.logger.LogInfo((object)(((Object)(object)NetworkManager.Singleton == (Object)null) ? "NetworkManager is null!" : "Initiating Networking"));
				NetworkManager.Singleton.AddNetworkPrefab(networkPrefab);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(StartOfRound), "Awake")]
		private static void ZinthosStartOfRound()
		{
			Plugin.AllPlayersLoaded = false;
			SpawnNetworkHandler();
			((MonoBehaviour)StartOfRound.Instance).StartCoroutine(WaitForPlayersToLoad());
		}

		private static void SpawnNetworkHandler()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
			{
				GameObject val = Object.Instantiate<GameObject>(networkPrefab, Vector3.zero, Quaternion.identity);
				val.GetComponent<NetworkObject>().Spawn(false);
				Plugin.logger.LogInfo((object)"Spawned Network Handler");
			}
		}

		private static void RequestModData()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkManager.Singleton.IsHost && !NetworkManager.Singleton.IsServer)
			{
				ZinNetworking.Instance.RequestClothesOnJoinServerRpc();
			}
		}

		private static IEnumerator WaitForPlayersToLoad()
		{
			Plugin.logger.LogInfo((object)"Waiting for all players to load!");
			yield return (object)new WaitUntil((Func<bool>)(() => StartOfRound.Instance.fullyLoadedPlayers.Count >= GameNetworkManager.Instance.connectedPlayers));
			yield return (object)new WaitForSeconds(0.5f);
			Plugin.logger.LogInfo((object)"All players loaded(?)");
			RequestModData();
			Plugin.AllPlayersLoaded = true;
		}
	}
	public class ZinNetworking : NetworkBehaviour
	{
		public static ZinNetworking Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
			Plugin.logger.LogInfo((object)"Zin Network Awake");
		}

		[ServerRpc(RequireOwnership = false)]
		internal void RequestClothesOnJoinServerRpc(ServerRpcParams serverRpcParams = default(ServerRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3136181203u, serverRpcParams, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3136181203u, serverRpcParams, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					Plugin.logger.LogInfo((object)$"[Server] Player (SenderClientId = {serverRpcParams.Receive.SenderClientId}) is requesting clothes from other players.");
					SendClothesToPlayerClientRpc(serverRpcParams.Receive.SenderClientId);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		internal void RequestClothesFromPlayerServerRpc(ulong target, ServerRpcParams serverRpcParams = default(ServerRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: 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_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(4077452656u, serverRpcParams, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, target);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 4077452656u, serverRpcParams, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					Plugin.logger.LogInfo((object)$"[Server] Player (SenderClientId = {serverRpcParams.Receive.SenderClientId}) is requesting clothes from player {target}.");
					SendClothesToPlayerClientRpc(serverRpcParams.Receive.SenderClientId, new ClientRpcParams
					{
						Send = new ClientRpcSendParams
						{
							TargetClientIds = new ulong[1] { target }
						}
					});
				}
			}
		}

		[ClientRpc]
		internal void SendClothesToPlayerClientRpc(ulong target, ClientRpcParams clientRpcParams = default(ClientRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1550778414u, clientRpcParams, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, target);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 1550778414u, clientRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			Plugin.logger.LogInfo((object)$"Player {target} has requested clothes.");
			if (target == NetworkManager.Singleton.LocalClientId)
			{
				return;
			}
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			if ((Object)(object)localPlayerController != (Object)null)
			{
				MRZINTHOS component = ((Component)localPlayerController).gameObject.GetComponent<MRZINTHOS>();
				if ((Object)(object)component != (Object)null)
				{
					Plugin.logger.LogInfo((object)$"Sending clothes to target: {target}");
					SendFromPlayerToTargetServerRpc(target, localPlayerController.playerClientId, Plugin.enableSweater.Value, Plugin.enableCollar.Value, Plugin.sweaterColor.Value);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		internal void SendFromPlayerToTargetServerRpc(ulong target, ulong player, bool sweater, bool collar, MRZINTHOS.SweaterColors sweaterColor)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: 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_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1907966917u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, target);
					BytePacker.WriteValueBitPacked(val2, player);
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref sweater, default(ForPrimitives));
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref collar, default(ForPrimitives));
					((FastBufferWriter)(ref val2)).WriteValueSafe<MRZINTHOS.SweaterColors>(ref sweaterColor, default(ForEnums));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1907966917u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					Plugin.logger.LogInfo((object)$"[Server] Received data from {player} and is sending it to {target}.");
					ReceiveDataFromPlayerClientRpc(player, sweater, collar, sweaterColor, new ClientRpcParams
					{
						Send = new ClientRpcSendParams
						{
							TargetClientIds = new ulong[1] { target }
						}
					});
				}
			}
		}

		[ClientRpc]
		internal void ReceiveDataFromPlayerClientRpc(ulong player, bool sweater, bool collar, MRZINTHOS.SweaterColors sweaterColor, ClientRpcParams clientRpcParams = default(ClientRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2035142953u, clientRpcParams, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, player);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref sweater, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref collar, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<MRZINTHOS.SweaterColors>(ref sweaterColor, default(ForEnums));
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2035142953u, clientRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost) || player == GetLocalPlayerID())
			{
				return;
			}
			Plugin.logger.LogInfo((object)$"Received data from {player}.");
			for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Length; i++)
			{
				PlayerControllerB val2 = StartOfRound.Instance.allPlayerScripts[i];
				if (val2.playerClientId == player && val2.isPlayerControlled)
				{
					MRZINTHOS component = ((Component)val2).gameObject.GetComponent<MRZINTHOS>();
					if ((Object)(object)component != (Object)null)
					{
						component.ChangeAllClothes(sweater, collar, sweaterColor, sendToNetwork: false);
					}
					else
					{
						Plugin.logger.LogInfo((object)$"Received data from player {player} but they aren't Zinthos?");
					}
					break;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		internal void SendToAllPlayersServerRpc(ulong player, bool sweater, bool collar, MRZINTHOS.SweaterColors sweaterColor)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1271191814u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, player);
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref sweater, default(ForPrimitives));
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref collar, default(ForPrimitives));
					((FastBufferWriter)(ref val2)).WriteValueSafe<MRZINTHOS.SweaterColors>(ref sweaterColor, default(ForEnums));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1271191814u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ReceiveDataFromPlayerClientRpc(player, sweater, collar, sweaterColor);
				}
			}
		}

		internal ulong GetLocalPlayerID()
		{
			return GameNetworkManager.Instance.localPlayerController.playerClientId;
		}

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

		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeRPCS_ZinNetworking()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			NetworkManager.__rpc_func_table.Add(3136181203u, new RpcReceiveHandler(__rpc_handler_3136181203));
			NetworkManager.__rpc_func_table.Add(4077452656u, new RpcReceiveHandler(__rpc_handler_4077452656));
			NetworkManager.__rpc_func_table.Add(1550778414u, new RpcReceiveHandler(__rpc_handler_1550778414));
			NetworkManager.__rpc_func_table.Add(1907966917u, new RpcReceiveHandler(__rpc_handler_1907966917));
			NetworkManager.__rpc_func_table.Add(2035142953u, new RpcReceiveHandler(__rpc_handler_2035142953));
			NetworkManager.__rpc_func_table.Add(1271191814u, new RpcReceiveHandler(__rpc_handler_1271191814));
		}

		private static void __rpc_handler_3136181203(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ServerRpcParams server = rpcParams.Server;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ZinNetworking)(object)target).RequestClothesOnJoinServerRpc(server);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4077452656(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong target2 = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref target2);
				ServerRpcParams server = rpcParams.Server;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ZinNetworking)(object)target).RequestClothesFromPlayerServerRpc(target2, server);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1550778414(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong target2 = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref target2);
				ClientRpcParams client = rpcParams.Client;
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((ZinNetworking)(object)target).SendClothesToPlayerClientRpc(target2, client);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1907966917(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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_0085: 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_00be: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong target2 = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref target2);
				ulong player = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref player);
				bool sweater = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref sweater, default(ForPrimitives));
				bool collar = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref collar, default(ForPrimitives));
				MRZINTHOS.SweaterColors sweaterColor = default(MRZINTHOS.SweaterColors);
				((FastBufferReader)(ref reader)).ReadValueSafe<MRZINTHOS.SweaterColors>(ref sweaterColor, default(ForEnums));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ZinNetworking)(object)target).SendFromPlayerToTargetServerRpc(target2, player, sweater, collar, sweaterColor);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2035142953(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong player = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref player);
				bool sweater = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref sweater, default(ForPrimitives));
				bool collar = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref collar, default(ForPrimitives));
				MRZINTHOS.SweaterColors sweaterColor = default(MRZINTHOS.SweaterColors);
				((FastBufferReader)(ref reader)).ReadValueSafe<MRZINTHOS.SweaterColors>(ref sweaterColor, default(ForEnums));
				ClientRpcParams client = rpcParams.Client;
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((ZinNetworking)(object)target).ReceiveDataFromPlayerClientRpc(player, sweater, collar, sweaterColor, client);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1271191814(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong player = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref player);
				bool sweater = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref sweater, default(ForPrimitives));
				bool collar = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref collar, default(ForPrimitives));
				MRZINTHOS.SweaterColors sweaterColor = default(MRZINTHOS.SweaterColors);
				((FastBufferReader)(ref reader)).ReadValueSafe<MRZINTHOS.SweaterColors>(ref sweaterColor, default(ForEnums));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ZinNetworking)(object)target).SendToAllPlayersServerRpc(player, sweater, collar, sweaterColor);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "ZinNetworking";
		}
	}
}
namespace ZinthosReplacement.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}