using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using ModelReplacement;
using ModelReplacement.AvatarBodyUpdater;
using PinkGhoulTrooper;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace PinkGhoulTrooper
{
	public sealed class FloorAlignedAvatarUpdater : AvatarUpdater
	{
		public override void AssignModelReplacement(GameObject player, GameObject replacement)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			((AvatarUpdater)this).AssignModelReplacement(player, replacement);
			base.rootPositionOffset = Vector3.zero;
		}

		protected override void UpdateModel()
		{
			//IL_0073: 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_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: 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_00c2: 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)
			((AvatarUpdater)this).UpdateModel();
			Transform avatarTransformFromBoneName = ((AvatarUpdater)this).GetAvatarTransformFromBoneName("spine");
			Transform avatarTransformFromBoneName2 = ((AvatarUpdater)this).GetAvatarTransformFromBoneName("toe.L");
			Transform avatarTransformFromBoneName3 = ((AvatarUpdater)this).GetAvatarTransformFromBoneName("toe.R");
			Transform playerTransformFromBoneName = ((AvatarUpdater)this).GetPlayerTransformFromBoneName("toe.L");
			Transform playerTransformFromBoneName2 = ((AvatarUpdater)this).GetPlayerTransformFromBoneName("toe.R");
			if (!((Object)(object)avatarTransformFromBoneName == (Object)null) && !((Object)(object)avatarTransformFromBoneName2 == (Object)null) && !((Object)(object)avatarTransformFromBoneName3 == (Object)null) && !((Object)(object)playerTransformFromBoneName == (Object)null) && !((Object)(object)playerTransformFromBoneName2 == (Object)null))
			{
				float num = (playerTransformFromBoneName.position.y + playerTransformFromBoneName2.position.y) * 0.5f;
				float num2 = (avatarTransformFromBoneName2.position.y + avatarTransformFromBoneName3.position.y) * 0.5f;
				avatarTransformFromBoneName.position += Vector3.up * (num - num2);
			}
		}
	}
}
namespace ClassicTroopers
{
	[BepInPlugin("clair.classictroopers", "Classic Troopers Suits", "0.1.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public sealed class Plugin : BaseUnityPlugin
	{
		internal static AssetBundle Bundle;

		internal static AssetBundle FixedRaiderBundle;

		private void Awake()
		{
			try
			{
				Bundle = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), "classictroopers"));
				if (!Object.op_Implicit((Object)(object)Bundle))
				{
					throw new InvalidOperationException("Classic Troopers bundle failed to load");
				}
				FixedRaiderBundle = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), "renegadehairfix"));
				if (!Object.op_Implicit((Object)(object)FixedRaiderBundle) || !Object.op_Implicit((Object)(object)FixedRaiderBundle.LoadAsset<GameObject>("Assets/Generated/RenegadeRaider.prefab")))
				{
					throw new InvalidOperationException("Missing corrected Renegade bundle");
				}
				string[] array = new string[3] { "AerialAssaultTrooper", "PurpleSkullTrooper", "RenegadeRaider" };
				foreach (string text in array)
				{
					if (!Object.op_Implicit((Object)(object)Bundle.LoadAsset<GameObject>("Assets/Generated/" + text + ".prefab")))
					{
						throw new InvalidOperationException("Missing character: " + text);
					}
				}
				ModelReplacementAPI.RegisterSuitModelReplacement("Aerial Assault Trooper", typeof(AerialReplacement));
				ModelReplacementAPI.RegisterSuitModelReplacement("Purple Skull Trooper", typeof(SkullReplacement));
				ModelReplacementAPI.RegisterSuitModelReplacement("Renegade Raider", typeof(RaiderReplacement));
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Three Classic Troopers suit models registered; Pink Ghoul is supplied by its preserved 1.0.3 plugin.");
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)ex);
			}
		}
	}
	public abstract class TrooperReplacement : BodyReplacementBase
	{
		protected abstract string Key { get; }

		protected override GameObject LoadAssetsAndReturnModel()
		{
			return ((Key == "RenegadeRaider") ? Plugin.FixedRaiderBundle : Plugin.Bundle).LoadAsset<GameObject>("Assets/Generated/" + Key + ".prefab");
		}

		protected override AvatarUpdater GetAvatarUpdater()
		{
			return (AvatarUpdater)(object)new FloorAlignedAvatarUpdater();
		}
	}
	public sealed class AerialReplacement : TrooperReplacement
	{
		protected override string Key => "AerialAssaultTrooper";
	}
	public sealed class SkullReplacement : TrooperReplacement
	{
		protected override string Key => "PurpleSkullTrooper";
	}
	public sealed class RaiderReplacement : TrooperReplacement
	{
		protected override string Key => "RenegadeRaider";
	}
}

using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("GuffsCarry")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("GuffsCarry")]
[assembly: AssemblyTitle("GuffsCarry")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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 GuffsCarry
{
	[BepInPlugin("guff.guffscarry", "GuffsCarry", "1.0.0")]
	[BepInProcess("Lethal Company.exe")]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Log;

		internal static ConfigEntry<bool> Enabled;

		internal static ConfigEntry<bool> MultipleTwoHanded;

		internal static ConfigEntry<bool> Weightless;

		private void Awake()
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			Log = ((BaseUnityPlugin)this).Logger;
			Enabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", true, "Master switch.");
			MultipleTwoHanded = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "MultipleTwoHanded", true, "Carry several two-handed items, and switch slots / pick things up while holding one.");
			Weightless = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Weightless", true, "Carry weight never slows you, drains stamina or lowers your jump.");
			new Harmony("guff.guffscarry").PatchAll(typeof(Patches));
			Log.LogInfo((object)"GuffsCarry 1.0.0 loaded");
		}
	}
	internal static class Patches
	{
		private static bool IsLocal(PlayerControllerB p)
		{
			if ((Object)(object)p != (Object)null && (Object)(object)GameNetworkManager.Instance != (Object)null)
			{
				return (Object)(object)p == (Object)(object)GameNetworkManager.Instance.localPlayerController;
			}
			return false;
		}

		private static bool TwoOn(PlayerControllerB p)
		{
			if (Plugin.Enabled.Value && Plugin.MultipleTwoHanded.Value)
			{
				return IsLocal(p);
			}
			return false;
		}

		private static bool WeightOn(PlayerControllerB p)
		{
			if (Plugin.Enabled.Value && Plugin.Weightless.Value)
			{
				return IsLocal(p);
			}
			return false;
		}

		private static void ClearTwoHanded(PlayerControllerB __instance)
		{
			if (TwoOn(__instance))
			{
				__instance.twoHanded = false;
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "BeginGrabObject")]
		[HarmonyPrefix]
		private static void BeginGrab(PlayerControllerB __instance)
		{
			ClearTwoHanded(__instance);
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Interact_performed")]
		[HarmonyPrefix]
		private static void Interact(PlayerControllerB __instance)
		{
			ClearTwoHanded(__instance);
		}

		[HarmonyPatch(typeof(PlayerControllerB), "ScrollMouse_performed")]
		[HarmonyPrefix]
		private static void Scroll(PlayerControllerB __instance)
		{
			ClearTwoHanded(__instance);
		}

		[HarmonyPatch(typeof(PlayerControllerB), "SetHoverTipAndCurrentInteractTrigger")]
		[HarmonyPrefix]
		private static void Hover(PlayerControllerB __instance)
		{
			ClearTwoHanded(__instance);
		}

		[HarmonyPatch(typeof(PlayerControllerB), "SwitchToItemSlot")]
		[HarmonyPostfix]
		private static void Switched(PlayerControllerB __instance)
		{
			ClearTwoHanded(__instance);
		}

		[HarmonyPatch(typeof(PlayerControllerB), "GrabObjectClientRpc")]
		[HarmonyPostfix]
		private static void Grabbed(PlayerControllerB __instance)
		{
			ClearTwoHanded(__instance);
		}

		private static void WeightPre(PlayerControllerB p, out float state)
		{
			state = float.NaN;
			if (WeightOn(p))
			{
				state = p.carryWeight;
				p.carryWeight = 1f;
			}
		}

		private static void WeightPost(PlayerControllerB p, float state)
		{
			if (!float.IsNaN(state))
			{
				float num = p.carryWeight - 1f;
				p.carryWeight = Mathf.Max(1f, state + num);
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Update")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static void UpdPre(PlayerControllerB __instance, out float __state)
		{
			ClearTwoHanded(__instance);
			WeightPre(__instance, out __state);
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Update")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void UpdPost(PlayerControllerB __instance, float __state)
		{
			WeightPost(__instance, __state);
		}

		[HarmonyPatch(typeof(PlayerControllerB), "LateUpdate")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static void LatePre(PlayerControllerB __instance, out float __state)
		{
			WeightPre(__instance, out __state);
		}

		[HarmonyPatch(typeof(PlayerControllerB), "LateUpdate")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void LatePost(PlayerControllerB __instance, float __state)
		{
			WeightPost(__instance, __state);
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Jump_performed")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static void JumpPre(PlayerControllerB __instance, out float __state)
		{
			WeightPre(__instance, out __state);
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Jump_performed")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void JumpPost(PlayerControllerB __instance, float __state)
		{
			WeightPost(__instance, __state);
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		private static void PJPre(object __instance, out float __state)
		{
			WeightPre(Traverse.Create(__instance).Field("<>4__this").GetValue<PlayerControllerB>(), out __state);
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		private static void PJPost(object __instance, float __state)
		{
			PlayerControllerB value = Traverse.Create(__instance).Field("<>4__this").GetValue<PlayerControllerB>();
			if ((Object)(object)value != (Object)null)
			{
				WeightPost(value, __state);
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "guff.guffscarry";

		public const string PLUGIN_NAME = "GuffsCarry";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LethalCasino;
using LethalCasino.Config;
using LethalCasino.Custom;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("GuffsCasinoPeek")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("GuffsCasinoPeek")]
[assembly: AssemblyTitle("GuffsCasinoPeek")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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 GuffsCasinoPeek
{
	internal class PeekController : MonoBehaviour
	{
		private static readonly Type TBlackjack = AccessTools.TypeByName("LethalCasino.Custom.Blackjack");

		private static readonly Type TSlot = AccessTools.TypeByName("LethalCasino.Custom.SlotMachine");

		private static readonly Type TRoulette = AccessTools.TypeByName("LethalCasino.Custom.Roulette");

		private static readonly Type TWheel = AccessTools.TypeByName("LethalCasino.Custom.TheWheel");

		private static readonly Type TCustomPlayer = AccessTools.TypeByName("LethalCasino.Custom.CustomPlayerController");

		private static readonly FieldInfo BjDeck = F(TBlackjack, "deck");

		private static readonly FieldInfo BjDealerCards = F(TBlackjack, "dealerCards");

		private static readonly FieldInfo BjPlayerCards = F(TBlackjack, "playerCards");

		private static readonly FieldInfo BjPlayers = F(TBlackjack, "gamblingPlayers");

		private static readonly FieldInfo BjInProgress = F(TBlackjack, "gameInProgress");

		private static readonly FieldInfo BjDealerTurn = F(TBlackjack, "isDealerTurn");

		private static readonly FieldInfo BjCompleted = F(TBlackjack, "playerCompletedTurn");

		private static readonly FieldInfo SlGamble = F(TSlot, "gambleInProgress");

		private static readonly FieldInfo SlOutcome = F(TSlot, "resultOutcome");

		private static readonly FieldInfo SlPlayer = F(TSlot, "gamblingPlayer");

		private static readonly FieldInfo RoSpinning = F(TRoulette, "isWheelSpinning");

		private static readonly FieldInfo RoResult = F(TRoulette, "resultNumber");

		private static readonly FieldInfo RoBetNumbers = F(TRoulette, "gambledScrapNumbers");

		private static readonly FieldInfo RoBetOwners = F(TRoulette, "gambledScrapOwners");

		private static readonly FieldInfo WhSpinning = F(TWheel, "isWheelSpinning");

		private static readonly FieldInfo WhTarget = F(TWheel, "targetWheelRotation");

		private static readonly FieldInfo WhSlices = F(TWheel, "wheelSlices");

		private static readonly FieldInfo WhPlayer = F(TWheel, "gamblingPlayer");

		private static readonly FieldInfo CpLuck = F(TCustomPlayer, "luckiness");

		private const float WheelSliceDeg = 16.363636f;

		private static readonly HashSet<int> RedNumbers = new HashSet<int>
		{
			1, 3, 5, 7, 9, 12, 14, 16, 18, 19,
			21, 23, 25, 27, 30, 32, 34, 36
		};

		private readonly List<Component> _blackjacks = new List<Component>();

		private readonly List<Component> _slots = new List<Component>();

		private readonly List<Component> _roulettes = new List<Component>();

		private readonly List<Component> _wheels = new List<Component>();

		private float _nextScan;

		private string _text = "";

		private GUIStyle _style;

		private GUIStyle _box;

		private bool _warnedMissing;

		private static bool IsHost
		{
			get
			{
				if ((Object)(object)NetworkManager.Singleton != (Object)null)
				{
					return NetworkManager.Singleton.IsServer;
				}
				return false;
			}
		}

		private static FieldInfo F(Type t, string name)
		{
			if (!(t == null))
			{
				return AccessTools.Field(t, name);
			}
			return null;
		}

		private static T Get<T>(FieldInfo f, object o, T fallback = default(T))
		{
			try
			{
				if (f == null || o == null)
				{
					return fallback;
				}
				return (f.GetValue(o) is T val) ? val : fallback;
			}
			catch
			{
				return fallback;
			}
		}

		private void Update()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			Keyboard current = Keyboard.current;
			if (current != null && (int)Plugin.ToggleKey.Value != 0)
			{
				try
				{
					if (((ButtonControl)current[Plugin.ToggleKey.Value]).wasPressedThisFrame && !TypingOrMenu())
					{
						Plugin.ShowOverlay.Value = !Plugin.ShowOverlay.Value;
					}
				}
				catch
				{
				}
			}
			if (!_warnedMissing && (TBlackjack == null || TSlot == null || TRoulette == null || TWheel == null))
			{
				_warnedMissing = true;
				Plugin.Log.LogWarning((object)"Some LethalCasino types were not found; this LethalCasino version may be unsupported (built for 1.1.3).");
			}
			if (!Plugin.ShowOverlay.Value)
			{
				_text = "";
				return;
			}
			if (Time.unscaledTime >= _nextScan)
			{
				_nextScan = Time.unscaledTime + 1f;
				Scan(TBlackjack, _blackjacks);
				Scan(TSlot, _slots);
				Scan(TRoulette, _roulettes);
				Scan(TWheel, _wheels);
			}
			try
			{
				_text = BuildText();
			}
			catch (Exception ex)
			{
				_text = "";
				Plugin.Log.LogDebug((object)ex);
			}
		}

		private static bool TypingOrMenu()
		{
			PlayerControllerB val = LocalPlayer();
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			if (!val.isTypingChat && !val.inTerminalMenu)
			{
				if ((Object)(object)val.quickMenuManager != (Object)null)
				{
					return val.quickMenuManager.isMenuOpen;
				}
				return false;
			}
			return true;
		}

		private static void Scan(Type t, List<Component> list)
		{
			list.Clear();
			if (t == null)
			{
				return;
			}
			Object[] array = Object.FindObjectsOfType(t);
			foreach (Object obj in array)
			{
				Component val = (Component)(object)((obj is Component) ? obj : null);
				if (val != null && (Object)(object)val != (Object)null)
				{
					list.Add(val);
				}
			}
		}

		private static PlayerControllerB LocalPlayer()
		{
			GameNetworkManager instance = GameNetworkManager.Instance;
			if (!((Object)(object)instance != (Object)null))
			{
				return null;
			}
			return instance.localPlayerController;
		}

		private static Vector3? ViewPos(PlayerControllerB local)
		{
			//IL_005a: 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)
			if ((Object)(object)local == (Object)null)
			{
				return null;
			}
			if (local.isPlayerDead && (Object)(object)StartOfRound.Instance != (Object)null && (Object)(object)StartOfRound.Instance.activeCamera != (Object)null)
			{
				return ((Component)StartOfRound.Instance.activeCamera).transform.position;
			}
			return ((Component)local).transform.position;
		}

		private string BuildText()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: 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_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB local = LocalPlayer();
			Vector3? val = ViewPos(local);
			if (!val.HasValue)
			{
				return "";
			}
			float value = Plugin.Range.Value;
			StringBuilder stringBuilder = new StringBuilder();
			if (Plugin.PeekBlackjack.Value)
			{
				foreach (Component item in Near(_blackjacks, val.Value, value))
				{
					BlackjackPanel(stringBuilder, item, local);
				}
			}
			if (Plugin.PeekSlots.Value)
			{
				List<Component> list = Near(_slots, val.Value, value).ToList();
				if (list.Count > 0)
				{
					SlotsPanel(stringBuilder, list, local);
				}
			}
			if (Plugin.PeekRoulette.Value)
			{
				foreach (Component item2 in Near(_roulettes, val.Value, value))
				{
					RoulettePanel(stringBuilder, item2, local);
				}
			}
			if (Plugin.PeekWheel.Value)
			{
				foreach (Component item3 in Near(_wheels, val.Value, value))
				{
					WheelPanel(stringBuilder, item3, local);
				}
			}
			if (stringBuilder.Length == 0)
			{
				return "";
			}
			stringBuilder.Insert(0, string.Format("<b>Casino Peek</b>  <color=#888888>({0} · {1} hides)</color>\n", IsHost ? "host" : "client", Plugin.ToggleKey.Value));
			return stringBuilder.ToString().TrimEnd();
		}

		private static IEnumerable<Component> Near(List<Component> list, Vector3 pos, float range)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			return from c in list
				where (Object)(object)c != (Object)null && Vector3.Distance(c.transform.position, pos) <= range
				orderby Vector3.Distance(c.transform.position, pos)
				select c;
		}

		private static string CardStr(Card c)
		{
			if (c == null)
			{
				return "?";
			}
			return string.Concat(str1: c.suit switch
			{
				"Hearts" => "<color=#ff6666>♥</color>", 
				"Diamonds" => "<color=#ff6666>♦</color>", 
				"Spades" => "♠", 
				"Clubs" => "♣", 
				_ => c.suit, 
			}, str0: c.face);
		}

		private static int HandValue(IEnumerable<Card> cards)
		{
			int num = 0;
			bool flag = false;
			foreach (Card card in cards)
			{
				int minValue = card.GetMinValue();
				num += minValue;
				if (minValue == 1)
				{
					flag = true;
				}
			}
			if (!flag || num + 10 > 21)
			{
				return num;
			}
			return num + 10;
		}

		private static string Hand(List<Card> cards)
		{
			if (cards != null && cards.Count != 0)
			{
				return string.Join(" ", cards.Select(CardStr)) + $"  = <b>{HandValue(cards)}</b>";
			}
			return "-";
		}

		private void BlackjackPanel(StringBuilder sb, Component bj, PlayerControllerB local)
		{
			sb.AppendLine("<b><color=#ffd24d>BLACKJACK</color></b>");
			bool num = Get(BjInProgress, bj, fallback: false);
			List<Card> list = Get<List<Card>>(BjDealerCards, bj);
			PlayerControllerB[] array = Get<PlayerControllerB[]>(BjPlayers, bj);
			List<Card>[] array2 = Get<List<Card>[]>(BjPlayerCards, bj);
			bool[] array3 = Get<bool[]>(BjCompleted, bj);
			bool flag = Get(BjDealerTurn, bj, fallback: false);
			List<Card> list2 = Get<List<Card>>(BjDeck, bj);
			if (!num || list == null || list.Count == 0)
			{
				sb.AppendLine("  Waiting for Deal. The deck is shuffled on the host when Deal is pressed.");
				sb.AppendLine();
				return;
			}
			sb.AppendLine("  Dealer: " + Hand(list) + ((list.Count >= 1 && !flag) ? "  <color=#aaaaaa>(hole card revealed)</color>" : ""));
			int num2 = -1;
			int num3 = 0;
			if (array != null)
			{
				for (int i = 0; i < array.Length; i++)
				{
					if (!((Object)(object)array[i] == (Object)null))
					{
						if ((Object)(object)array[i] == (Object)(object)local)
						{
							num2 = i;
						}
						else if (array3 == null || i >= array3.Length || !array3[i])
						{
							num3++;
						}
					}
				}
			}
			List<Card> list3 = ((num2 >= 0 && array2 != null && num2 < array2.Length) ? array2[num2] : null);
			if (list3 != null)
			{
				sb.AppendLine("  You:    " + Hand(list3));
			}
			if (list2 == null || list2.Count <= 0)
			{
				sb.AppendLine("  <color=#aaaaaa>Next cards: only visible when you are the host.</color>");
				sb.AppendLine();
				return;
			}
			int num4 = Mathf.Min(Plugin.NextCardsShown.Value, list2.Count);
			if (num4 > 0)
			{
				List<string> list4 = new List<string>();
				for (int j = 0; j < num4; j++)
				{
					list4.Add(CardStr(list2[list2.Count - 1 - j]));
				}
				sb.AppendLine("  Next cards: " + string.Join(", ", list4));
			}
			if (flag)
			{
				var (v, list5) = SimDealer(list, list2, 0);
				sb.AppendLine("  Dealer will draw " + ((list5.Count == 0) ? "nothing" : string.Join(" ", list5.Select(CardStr))) + " → <b>" + Fmt(v) + "</b>");
			}
			else if (list3 != null && list3.Count > 0 && (array3 == null || num2 >= array3.Length || !array3[num2]))
			{
				PlanForMe(sb, list3, list, list2, local);
				if (num3 > 0)
				{
					sb.AppendLine($"  <color=#ffaa55>{num3} other player(s) still playing: any card they take first shifts these predictions.</color>");
				}
			}
			sb.AppendLine();
		}

		private static string Fmt(int v)
		{
			if (v <= 21)
			{
				return v.ToString();
			}
			return $"{v} BUST";
		}

		private static (int final, List<Card> draws) SimDealer(List<Card> dealer, List<Card> deck, int skip)
		{
			List<Card> list = new List<Card>(dealer);
			List<Card> list2 = new List<Card>();
			int num = deck.Count - 1 - skip;
			while (HandValue(list) < 17 && num >= 0)
			{
				list.Add(deck[num]);
				list2.Add(deck[num]);
				num--;
			}
			return (final: HandValue(list), draws: list2);
		}

		private void PlanForMe(StringBuilder sb, List<Card> myHand, List<Card> dealer, List<Card> deck, PlayerControllerB local)
		{
			string text = null;
			int num = -1;
			List<Card> list = new List<Card>(myHand);
			for (int i = 0; i <= 5 && i <= deck.Count; i++)
			{
				if (i > 0)
				{
					list.Add(deck[deck.Count - i]);
				}
				int num2 = HandValue(list);
				string text2 = ((i == 0) ? "Stand now" : string.Format("Hit {0}× ({1})", i, string.Join(" ", list.Skip(myHand.Count).Select(CardStr))));
				if (num2 > 21)
				{
					string arg = LuckNote(local);
					sb.AppendLine($"  {text2}: you {num2} <color=#ff5555>BUST</color>{arg}");
					break;
				}
				int item = SimDealer(dealer, deck, i).final;
				string text3;
				int num3;
				if (item > 21 || num2 > item)
				{
					text3 = "<color=#55ff55>WIN</color>";
					num3 = 2;
				}
				else if (num2 == item)
				{
					text3 = "<color=#ffff55>PUSH</color>";
					num3 = 1;
				}
				else
				{
					text3 = "<color=#ff5555>LOSE</color>";
					num3 = 0;
				}
				sb.AppendLine($"  {text2}: you {num2} vs dealer {Fmt(item)} → {text3}");
				if (num3 > num)
				{
					num = num3;
					text = text2;
				}
			}
			if (text != null)
			{
				sb.AppendLine("  <b>Best: " + text + "</b>");
			}
		}

		private static string LuckNote(PlayerControllerB local)
		{
			try
			{
				Dictionary<string, float> dictionary = Plugin.configFile?.configValues;
				if (dictionary == null)
				{
					return "";
				}
				float value;
				float num = (dictionary.TryGetValue(Constants.BLACKJACK_LUCKINESS, out value) ? value : 0f);
				float value2;
				float num2 = (dictionary.TryGetValue(Constants.PIPE_LUCKINESS, out value2) ? value2 : 0f);
				float num3 = 0f;
				if (TCustomPlayer != null && (Object)(object)local != (Object)null)
				{
					Component component = ((Component)local).GetComponent(TCustomPlayer);
					if ((Object)(object)component != (Object)null)
					{
						num3 = Get(CpLuck, component, 0f);
					}
				}
				float num4 = num + num3 * 2f * num2 / 100f;
				return (num4 > 0f) ? $" <color=#aaaaaa>({num4:0.#}% luck chance to swap in a safe card)</color>" : "";
			}
			catch
			{
				return "";
			}
		}

		private static string SlotOutcome(string o)
		{
			return o switch
			{
				"three_sevens" => "<color=#55ff55>THREE 7s → x10</color>", 
				"three_bars" => "<color=#55ff55>THREE BARS → x3</color>", 
				"three_bells" => "<color=#55ff55>THREE BELLS → x3</color>", 
				"three_fruits" => "<color=#55ff55>THREE FRUITS → x2</color>", 
				"two_match" => "<color=#ffff55>PAIR → x1.5</color>", 
				"no_matches" => "<color=#ff9955>NO MATCH → x0.5</color>", 
				"three_skulls" => "<color=#ff5555>THREE SKULLS → lose all</color>", 
				_ => o ?? "?", 
			};
		}

		private void SlotsPanel(StringBuilder sb, List<Component> slots, PlayerControllerB local)
		{
			sb.AppendLine("<b><color=#ffd24d>SLOTS</color></b>");
			int num = 1;
			foreach (Component slot in slots)
			{
				if (Get(SlGamble, slot, fallback: false))
				{
					PlayerControllerB val = Get<PlayerControllerB>(SlPlayer, slot);
					string arg = (((Object)(object)val == (Object)null) ? "" : (((Object)(object)val == (Object)(object)local) ? " (you)" : (" (" + val.playerUsername + ")")));
					sb.AppendLine($"  Machine {num}{arg}: {SlotOutcome(Get<string>(SlOutcome, slot))}");
				}
				else
				{
					sb.AppendLine($"  Machine {num}: idle");
				}
				num++;
			}
			sb.AppendLine("  <color=#aaaaaa>Rolled on the host at the moment you pull. All machines have the same odds; result shows as soon as the reels start.</color>");
			sb.AppendLine();
		}

		private void RoulettePanel(StringBuilder sb, Component r, PlayerControllerB local)
		{
			sb.AppendLine("<b><color=#ffd24d>ROULETTE</color></b>");
			if (!Get(RoSpinning, r, fallback: false))
			{
				sb.AppendLine("  Not spinning. The number is picked on the host when Spin is pressed.");
				sb.AppendLine();
				return;
			}
			int num = Get(RoResult, r, 0);
			string arg = ((num == 0) ? "<color=#55ff55>green</color>" : (RedNumbers.Contains(num) ? "<color=#ff5555>red</color>" : "black"));
			sb.AppendLine($"  Ball will land on <b>{num}</b> ({arg})");
			IDictionary dictionary = Get<IDictionary>(RoBetNumbers, r);
			IDictionary dictionary2 = Get<IDictionary>(RoBetOwners, r);
			if (dictionary != null && dictionary2 != null && dictionary.Count > 0)
			{
				int num2 = 0;
				int num3 = 0;
				foreach (DictionaryEntry item in dictionary)
				{
					if (!dictionary2.Contains(item.Key))
					{
						continue;
					}
					object? obj = dictionary2[item.Key];
					PlayerControllerB val = (PlayerControllerB)((obj is PlayerControllerB) ? obj : null);
					if (val != null && !((Object)(object)val != (Object)(object)local))
					{
						if (item.Value is int[] source && source.Contains(num))
						{
							num2++;
						}
						else
						{
							num3++;
						}
					}
				}
				if (num2 + num3 > 0)
				{
					sb.AppendLine($"  Your bets: <color=#55ff55>{num2} win</color>, <color=#ff5555>{num3} lose</color>");
				}
			}
			sb.AppendLine();
		}

		private void WheelPanel(StringBuilder sb, Component w, PlayerControllerB local)
		{
			sb.AppendLine("<b><color=#ffd24d>THE WHEEL</color></b>");
			if (!Get(WhSpinning, w, fallback: false))
			{
				sb.AppendLine("  Not spinning. The slice is picked on the host when you spin.");
				sb.AppendLine();
				return;
			}
			float num = Get(WhTarget, w, 0f);
			string[] array = Get<string[]>(WhSlices, w);
			int num2 = ((array != null) ? array.Length : 22);
			int num3 = Mathf.FloorToInt(((num % 360f + 360f) % 360f + 8.181818f) / 16.363636f) % num2;
			string text = ((array != null && num3 >= 0 && num3 < array.Length) ? array[num3] : $"slice {num3}");
			PlayerControllerB val = Get<PlayerControllerB>(WhPlayer, w);
			string text2 = (((Object)(object)val == (Object)null) ? "" : (((Object)(object)val == (Object)(object)local) ? " (you)" : (" (" + val.playerUsername + ")")));
			object obj;
			switch (text)
			{
			default:
				obj = "#ffff55";
				break;
			case "+500":
			case "+250":
				obj = "#55ff55";
				break;
			case "+0":
				obj = "#ff5555";
				break;
			}
			string text3 = (string)obj;
			sb.AppendLine("  Will land on <b><color=" + text3 + ">" + text + "</color></b>" + text2);
			sb.AppendLine();
		}

		private void OnGUI()
		{
			//IL_0044: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			if (!string.IsNullOrEmpty(_text) && Plugin.ShowOverlay.Value)
			{
				if (_style == null || _style.fontSize != Plugin.FontSize.Value)
				{
					_style = new GUIStyle(GUI.skin.label)
					{
						richText = true,
						fontSize = Plugin.FontSize.Value,
						wordWrap = true
					};
					_style.normal.textColor = Color.white;
					_box = new GUIStyle(GUI.skin.box);
				}
				float num = Mathf.Min(560f, (float)Screen.width - Plugin.PanelX.Value - 10f);
				GUIContent val = new GUIContent(_text);
				float num2 = _style.CalcHeight(val, num - 20f);
				Rect val2 = default(Rect);
				((Rect)(ref val2))..ctor(Plugin.PanelX.Value, Plugin.PanelY.Value, num, num2 + 16f);
				Color color = GUI.color;
				GUI.color = new Color(0f, 0f, 0f, 0.75f);
				GUI.Box(val2, GUIContent.none, _box);
				GUI.color = color;
				GUI.Label(new Rect(((Rect)(ref val2)).x + 10f, ((Rect)(ref val2)).y + 8f, num - 20f, num2), val, _style);
			}
		}
	}
	[BepInPlugin("guff.guffscasinopeek", "GuffsCasinoPeek", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInProcess("Lethal Company.exe")]
	public class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "guff.guffscasinopeek";

		public const string PluginName = "GuffsCasinoPeek";

		public const string PluginVersion = "1.0.0";

		public const string LethalCasinoGuid = "mrgrm7.LethalCasino";

		internal static ManualLogSource Log;

		internal static ConfigEntry<bool> ShowOverlay;

		internal static ConfigEntry<Key> ToggleKey;

		internal static ConfigEntry<float> Range;

		internal static ConfigEntry<int> NextCardsShown;

		internal static ConfigEntry<bool> PeekBlackjack;

		internal static ConfigEntry<bool> PeekSlots;

		internal static ConfigEntry<bool> PeekRoulette;

		internal static ConfigEntry<bool> PeekWheel;

		internal static ConfigEntry<float> PanelX;

		internal static ConfigEntry<float> PanelY;

		internal static ConfigEntry<int> FontSize;

		private void Awake()
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Expected O, but got Unknown
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Expected O, but got Unknown
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			Log = ((BaseUnityPlugin)this).Logger;
			ShowOverlay = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ShowOverlay", true, "Overlay is visible (toggled in game with ToggleKey; remembered).");
			ToggleKey = ((BaseUnityPlugin)this).Config.Bind<Key>("General", "ToggleKey", (Key)101, "Show/hide the overlay. Unity Input System key name.");
			Range = ((BaseUnityPlugin)this).Config.Bind<float>("General", "Range", 7f, new ConfigDescription("Show a game's panel when you are within this many meters of it.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 50f), Array.Empty<object>()));
			NextCardsShown = ((BaseUnityPlugin)this).Config.Bind<int>("Blackjack", "NextCardsShown", 6, new ConfigDescription("How many upcoming deck cards to list (host only).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 20), Array.Empty<object>()));
			PeekBlackjack = ((BaseUnityPlugin)this).Config.Bind<bool>("Games", "Blackjack", true, "Show the Blackjack panel.");
			PeekSlots = ((BaseUnityPlugin)this).Config.Bind<bool>("Games", "Slots", true, "Show the slot machine panel.");
			PeekRoulette = ((BaseUnityPlugin)this).Config.Bind<bool>("Games", "Roulette", true, "Show the Roulette panel.");
			PeekWheel = ((BaseUnityPlugin)this).Config.Bind<bool>("Games", "TheWheel", true, "Show The Wheel panel.");
			PanelX = ((BaseUnityPlugin)this).Config.Bind<float>("UI", "PanelX", 20f, "Panel left edge in pixels.");
			PanelY = ((BaseUnityPlugin)this).Config.Bind<float>("UI", "PanelY", 160f, "Panel top edge in pixels.");
			FontSize = ((BaseUnityPlugin)this).Config.Bind<int>("UI", "FontSize", 16, new ConfigDescription("Overlay font size.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(10, 40), Array.Empty<object>()));
			GameObject val = new GameObject("GuffsCasinoPeek");
			Object.DontDestroyOnLoad((Object)val);
			((Object)val).hideFlags = (HideFlags)61;
			val.AddComponent<PeekController>();
			Log.LogInfo((object)string.Format("{0} {1} loaded (read-only peek; toggle {2}).", "GuffsCasinoPeek", "1.0.0", ToggleKey.Value));
		}
	}
}