using System;
using System.Collections;
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 BepInEx;
using BepInEx.Configuration;
using Extensions;
using HarmonyLib;
using Items_Mod_For_Gamble.ModdedItem;
using Mirror;
using TryConnect;
using UnityEngine;
using UnityEngine.SceneManagement;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("0.0.0.0")]
[HarmonyPatch(typeof(ElevatorGuy))]
public static class ElevatorGuyDebugPatch
{
private static FieldInfo assetIdField = typeof(NetworkIdentity).GetField("_assetId", BindingFlags.Instance | BindingFlags.NonPublic);
private static FieldInfo hasSpawnedField = typeof(ElevatorGuy).GetField("_hasSpawned", BindingFlags.Instance | BindingFlags.NonPublic);
private static FieldInfo isSpawningField = typeof(ElevatorGuy).GetField("_isSpawning", BindingFlags.Instance | BindingFlags.NonPublic);
[HarmonyPrefix]
[HarmonyPatch("ItemInitializeRoutine")]
public static void Prefix_ItemInitializeRoutine(ElevatorGuy __instance)
{
Debug.Log((object)"[ElevatorGuy] ========== ITEM INITIALIZE ROUTINE STARTING ==========");
ItemManager instance = NetworkSingleton<ItemManager>.Instance;
if ((Object)(object)instance != (Object)null && instance.currentItems != null)
{
Debug.Log((object)$"[ElevatorGuy] ItemManager.currentItems contains {instance.currentItems.Count} items:");
int num = 0;
{
SpawnableSO val = default(SpawnableSO);
foreach (SpawnableSO currentItem in instance.currentItems)
{
if ((Object)(object)currentItem == (Object)null)
{
Debug.Log((object)$"[ElevatorGuy] [{num}] NULL item");
num++;
continue;
}
bool flag = TryConnectApi.TryGetCustomSpawnable(currentItem.spawnableID, ref val);
GameObject prefab = currentItem.prefab;
uint num2 = 0u;
string text = "NULL";
if ((Object)(object)prefab != (Object)null)
{
text = ((Object)prefab).name;
NetworkIdentity component = prefab.GetComponent<NetworkIdentity>();
if ((Object)(object)component != (Object)null && assetIdField != null)
{
num2 = (uint)assetIdField.GetValue(component);
}
}
Debug.Log((object)$"[ElevatorGuy] [{num}] Item: {currentItem.spawnableName}");
Debug.Log((object)$"[ElevatorGuy] ID: {currentItem.spawnableID}");
Debug.Log((object)$"[ElevatorGuy] Is Custom: {flag}");
Debug.Log((object)("[ElevatorGuy] Prefab: " + text));
Debug.Log((object)$"[ElevatorGuy] AssetId: {num2}");
Debug.Log((object)"[ElevatorGuy] ---");
num++;
}
return;
}
}
Debug.Log((object)"[ElevatorGuy] ItemManager is null or has no currentItems!");
}
[HarmonyPostfix]
[HarmonyPatch("ItemInitializeRoutine")]
public static void Postfix_ItemInitializeRoutine(ElevatorGuy __instance)
{
bool flag = hasSpawnedField != null && (bool)hasSpawnedField.GetValue(__instance);
bool flag2 = isSpawningField != null && (bool)isSpawningField.GetValue(__instance);
Debug.Log((object)$"[ElevatorGuy] ========== ITEM INITIALIZE ROUTINE FINISHED ========== HasSpawned: {flag}, IsSpawning: {flag2}");
}
[HarmonyPrefix]
[HarmonyPatch("ItemSpawnRoutine")]
public static void Prefix_ItemSpawnRoutine(ElevatorGuy __instance)
{
Debug.Log((object)"[ElevatorGuy] ========== ITEM SPAWN ROUTINE STARTING ==========");
ItemManager instance = NetworkSingleton<ItemManager>.Instance;
if ((Object)(object)instance != (Object)null && instance.spawnedItemInstances != null)
{
Debug.Log((object)$"[ElevatorGuy] spawnedItemInstances contains {instance.spawnedItemInstances.Count} items");
}
}
[HarmonyPostfix]
[HarmonyPatch("ItemSpawnRoutine")]
public static void Postfix_ItemSpawnRoutine(ElevatorGuy __instance)
{
bool flag = isSpawningField != null && (bool)isSpawningField.GetValue(__instance);
Debug.Log((object)$"[ElevatorGuy] ========== ITEM SPAWN ROUTINE FINISHED ========== IsSpawning: {flag}");
}
}
[HarmonyPatch(typeof(Object), "Instantiate", new Type[]
{
typeof(GameObject),
typeof(Vector3),
typeof(Quaternion)
})]
public static class InstantiateDebugPatch
{
private static FieldInfo assetIdField = typeof(NetworkIdentity).GetField("_assetId", BindingFlags.Instance | BindingFlags.NonPublic);
[HarmonyPostfix]
public static void Postfix_Instantiate(GameObject original, Vector3 position, Quaternion rotation, ref Object __result)
{
//IL_014b: Unknown result type (might be due to invalid IL or missing references)
StackTrace stackTrace = new StackTrace();
bool flag = false;
StackFrame[] frames = stackTrace.GetFrames();
foreach (StackFrame stackFrame in frames)
{
if (stackFrame.GetMethod().DeclaringType == typeof(ElevatorGuy))
{
flag = true;
break;
}
}
if (!flag || !(__result != (Object)null))
{
return;
}
Object obj = __result;
GameObject val = (GameObject)(object)((obj is GameObject) ? obj : null);
if ((Object)(object)val != (Object)null)
{
NetworkIdentity component = val.GetComponent<NetworkIdentity>();
uint num = 0u;
if ((Object)(object)component != (Object)null && assetIdField != null)
{
num = (uint)assetIdField.GetValue(component);
}
Item component2 = val.GetComponent<Item>();
string text = (((Object)(object)component2 != (Object)null && (Object)(object)component2.spawnableSo != (Object)null) ? component2.spawnableSo.spawnableName : ((Object)val).name);
Debug.Log((object)("[ElevatorGuy] INSTANTIATED: " + text));
Debug.Log((object)("[ElevatorGuy] - From prefab: " + (((Object)(object)original != (Object)null) ? ((Object)original).name : "NULL")));
Debug.Log((object)$"[ElevatorGuy] - AssetId on instantiated object: {num}");
Debug.Log((object)$"[ElevatorGuy] - Position: {position}");
}
}
}
[HarmonyPatch]
public static class NetworkManagerRegistrationPatch
{
private static FieldInfo assetIdField = typeof(NetworkIdentity).GetField("_assetId", BindingFlags.Instance | BindingFlags.NonPublic);
private static List<GameObject> registeredPrefabs = new List<GameObject>();
[HarmonyPrefix]
[HarmonyPatch(typeof(CustomNetworkManager), "OnStopServer")]
public static void OnStopServer(CustomNetworkManager __instance)
{
Debug.Log((object)"[Armory] OnStopServer - Clearing custom prefabs from NetworkManager");
for (int num = ((NetworkManager)__instance).spawnPrefabs.Count - 1; num >= 0; num--)
{
if (registeredPrefabs.Contains(((NetworkManager)__instance).spawnPrefabs[num]))
{
((NetworkManager)__instance).spawnPrefabs.RemoveAt(num);
}
}
registeredPrefabs.Clear();
}
[HarmonyPrefix]
[HarmonyPatch(typeof(CustomNetworkManager), "OnStopClient")]
public static void OnStopClient(CustomNetworkManager __instance)
{
Debug.Log((object)"[Armory] OnStopClient - Clearing custom prefabs from NetworkManager");
for (int num = ((NetworkManager)__instance).spawnPrefabs.Count - 1; num >= 0; num--)
{
if (registeredPrefabs.Contains(((NetworkManager)__instance).spawnPrefabs[num]))
{
((NetworkManager)__instance).spawnPrefabs.RemoveAt(num);
}
}
registeredPrefabs.Clear();
}
[HarmonyPrefix]
[HarmonyPatch(typeof(CustomNetworkManager), "OnStartServer")]
public static void OnStartServer(CustomNetworkManager __instance)
{
RegisterAllCustomPrefabs(__instance);
}
[HarmonyPrefix]
[HarmonyPatch(typeof(CustomNetworkManager), "OnClientConnect")]
public static void OnClientConnect(CustomNetworkManager __instance)
{
RegisterAllCustomPrefabs(__instance);
}
[HarmonyPrefix]
[HarmonyPatch(typeof(NetworkManager), "StartHost")]
public static void OnStartHost(NetworkManager __instance)
{
CustomNetworkManager val = (CustomNetworkManager)(object)((__instance is CustomNetworkManager) ? __instance : null);
if (val != null)
{
RegisterAllCustomPrefabs(val);
}
}
private static void RegisterAllCustomPrefabs(CustomNetworkManager networkManager)
{
if ((Object)(object)networkManager == (Object)null)
{
return;
}
Debug.Log((object)"[Armory] Registering custom prefabs with NetworkManager");
for (int num = ((NetworkManager)networkManager).spawnPrefabs.Count - 1; num >= 0; num--)
{
if ((Object)(object)((NetworkManager)networkManager).spawnPrefabs[num] == (Object)null)
{
((NetworkManager)networkManager).spawnPrefabs.RemoveAt(num);
}
}
TryConnectRegisteredItemInfo[] registeredItems = TryConnectApi.GetRegisteredItems();
int num2 = 0;
TryConnectRegisteredItemInfo[] array = registeredItems;
SpawnableSO val2 = default(SpawnableSO);
foreach (TryConnectRegisteredItemInfo val in array)
{
if (TryConnectApi.TryGetCustomSpawnable(val.SpawnableId, ref val2) && (Object)(object)val2 != (Object)null && (Object)(object)val2.prefab != (Object)null)
{
uint num3 = ArmoryPlugin.GenerateDeterministicAssetId(val.OwnerGuid, val.Key);
NetworkIdentity component = val2.prefab.GetComponent<NetworkIdentity>();
if ((Object)(object)component != (Object)null && assetIdField != null && (uint)assetIdField.GetValue(component) == 0)
{
assetIdField.SetValue(component, num3);
Debug.Log((object)$"[Armory] Set assetId for {val.Key} to {num3}");
}
if (!((NetworkManager)networkManager).spawnPrefabs.Contains(val2.prefab))
{
((NetworkManager)networkManager).spawnPrefabs.Add(val2.prefab);
registeredPrefabs.Add(val2.prefab);
Debug.Log((object)("[Armory] Added " + val.Key + " to NetworkManager spawnPrefabs"));
num2++;
}
NetworkClient.RegisterPrefab(val2.prefab, num3);
}
}
if (num2 > 0)
{
Debug.Log((object)$"[Armory] Registered {num2} custom prefabs with NetworkManager (total: {((NetworkManager)networkManager).spawnPrefabs.Count})");
}
}
}
[HarmonyPatch(typeof(Coordinator), "ServerThrow")]
public static class CoordinatorThrowPatch
{
[HarmonyPostfix]
private static void Postfix(Coordinator __instance)
{
string text = ((Object)((Component)__instance).gameObject).name.ToLower();
if (text.Contains("voodoo doll"))
{
AccessTools.Field(typeof(Coordinator), "_isBreakable").SetValue(__instance, false);
}
}
}
[HarmonyPatch(typeof(Drink), "ServerThrow")]
public static class DrinkThrowPatch
{
[HarmonyPostfix]
private static void Postfix(Drink __instance)
{
string text = ((Object)((Component)__instance).gameObject).name.ToLower();
if (text.Contains("blind luck"))
{
AccessTools.Field(typeof(Drink), "_isBreakable").SetValue(__instance, false);
}
}
}
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("Armory-Mod", "Armory", "0.2.0")]
public sealed class ArmoryPlugin : BaseUnityPlugin
{
[HarmonyPatch]
public static class BlockTicketFizzFromShopPatch
{
[HarmonyPostfix]
[HarmonyPatch]
public static void Postfix(GameObject fallbackPrefab, ref GameObject __result)
{
if ((Object)(object)__result != (Object)null && ((Object)__result).name.Contains("Ticket Fizz"))
{
Debug.Log((object)"[Armory] Blocked Ticket Fizz from shop");
__result = fallbackPrefab;
}
}
private static MethodBase TargetMethod()
{
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (Assembly assembly in assemblies)
{
if (assembly.GetName().Name.Contains("TryConnect"))
{
Type type = assembly.GetType("TryConnect.RuntimeItemRegistry");
if (type != null)
{
return AccessTools.Method(type, "GetShopReplacement", (Type[])null, (Type[])null);
}
}
}
return null;
}
}
[HarmonyPatch]
public static class BlockLoadedChipFromShopPatch
{
[HarmonyPostfix]
[HarmonyPatch]
public static void Postfix(GameObject fallbackPrefab, ref GameObject __result)
{
if ((Object)(object)__result != (Object)null && ((Object)__result).name.Contains("Loaded Chip"))
{
Debug.Log((object)"[Armory] Blocked Loaded Chip from shop");
__result = fallbackPrefab;
}
}
private static MethodBase TargetMethod()
{
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (Assembly assembly in assemblies)
{
if (assembly.GetName().Name.Contains("TryConnect"))
{
Type type = assembly.GetType("TryConnect.RuntimeItemRegistry");
if (type != null)
{
return AccessTools.Method(type, "GetShopReplacement", (Type[])null, (Type[])null);
}
}
}
return null;
}
}
[HarmonyPatch]
public static class BlockTicketFizzAndLoadedChipSpawnPatch
{
[HarmonyPrefix]
[HarmonyPatch]
public static bool Prefix(GameObject prefab, ref bool __result)
{
if ((Object)(object)prefab != (Object)null && (((Object)prefab).name.Contains("Ticket Fizz") || ((Object)prefab).name.Contains("Loaded Chip")))
{
Debug.Log((object)("[Armory] Blocked spawning of " + ((Object)prefab).name));
__result = false;
return false;
}
return true;
}
private static MethodBase TargetMethod()
{
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (Assembly assembly in assemblies)
{
if (assembly.GetName().Name.Contains("TryConnect"))
{
Type type = assembly.GetType("TryConnect.RuntimeItemRegistry");
if (type != null)
{
return AccessTools.Method(type, "TrySpawnRegisteredPrefab", (Type[])null, (Type[])null);
}
}
}
return null;
}
}
internal static ConfigEntry<bool> enableCursedCoin;
internal static ConfigEntry<bool> enablePills;
internal static ConfigEntry<bool> enableBlind;
internal static ConfigEntry<bool> enableDoll;
internal static ConfigEntry<bool> enableTaxes;
internal static ConfigEntry<bool> enableEnergy;
internal static uint GenerateDeterministicAssetId(string ownerGuid, string key)
{
string text = ownerGuid + ":" + key;
uint num = 5381u;
string text2 = text;
foreach (char c in text2)
{
num = (num << 5) + num + c;
}
return (num == 0) ? 1u : num;
}
private void Awake()
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Expected O, but got Unknown
//IL_0102: Unknown result type (might be due to invalid IL or missing references)
//IL_0107: Unknown result type (might be due to invalid IL or missing references)
//IL_0113: 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_012b: Unknown result type (might be due to invalid IL or missing references)
//IL_0137: Unknown result type (might be due to invalid IL or missing references)
//IL_0143: Unknown result type (might be due to invalid IL or missing references)
//IL_0144: Unknown result type (might be due to invalid IL or missing references)
//IL_014e: Unknown result type (might be due to invalid IL or missing references)
//IL_0159: Unknown result type (might be due to invalid IL or missing references)
//IL_0161: Unknown result type (might be due to invalid IL or missing references)
//IL_0169: Unknown result type (might be due to invalid IL or missing references)
//IL_0171: Unknown result type (might be due to invalid IL or missing references)
//IL_017a: Unknown result type (might be due to invalid IL or missing references)
//IL_0182: Unknown result type (might be due to invalid IL or missing references)
//IL_018b: Expected O, but got Unknown
//IL_018d: Unknown result type (might be due to invalid IL or missing references)
//IL_0192: Unknown result type (might be due to invalid IL or missing references)
//IL_019e: Unknown result type (might be due to invalid IL or missing references)
//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
//IL_0205: Unknown result type (might be due to invalid IL or missing references)
//IL_0206: Unknown result type (might be due to invalid IL or missing references)
//IL_0210: Unknown result type (might be due to invalid IL or missing references)
//IL_021b: Unknown result type (might be due to invalid IL or missing references)
//IL_0223: Unknown result type (might be due to invalid IL or missing references)
//IL_022b: Unknown result type (might be due to invalid IL or missing references)
//IL_0233: Unknown result type (might be due to invalid IL or missing references)
//IL_023c: Unknown result type (might be due to invalid IL or missing references)
//IL_0244: Unknown result type (might be due to invalid IL or missing references)
//IL_024e: Expected O, but got Unknown
//IL_0251: Unknown result type (might be due to invalid IL or missing references)
//IL_0256: Unknown result type (might be due to invalid IL or missing references)
//IL_0263: Unknown result type (might be due to invalid IL or missing references)
//IL_028a: Unknown result type (might be due to invalid IL or missing references)
//IL_028f: Unknown result type (might be due to invalid IL or missing references)
//IL_029b: Unknown result type (might be due to invalid IL or missing references)
//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
//IL_0304: Unknown result type (might be due to invalid IL or missing references)
//IL_030c: Unknown result type (might be due to invalid IL or missing references)
//IL_0314: Unknown result type (might be due to invalid IL or missing references)
//IL_031d: Unknown result type (might be due to invalid IL or missing references)
//IL_0326: Unknown result type (might be due to invalid IL or missing references)
//IL_0330: Expected O, but got Unknown
//IL_0333: Unknown result type (might be due to invalid IL or missing references)
//IL_0338: Unknown result type (might be due to invalid IL or missing references)
//IL_0345: Unknown result type (might be due to invalid IL or missing references)
//IL_036c: Unknown result type (might be due to invalid IL or missing references)
//IL_0371: Unknown result type (might be due to invalid IL or missing references)
//IL_037d: Unknown result type (might be due to invalid IL or missing references)
//IL_0389: Unknown result type (might be due to invalid IL or missing references)
//IL_0395: Unknown result type (might be due to invalid IL or missing references)
//IL_03a1: Unknown result type (might be due to invalid IL or missing references)
//IL_03ad: Unknown result type (might be due to invalid IL or missing references)
//IL_03ae: Unknown result type (might be due to invalid IL or missing references)
//IL_03b8: Unknown result type (might be due to invalid IL or missing references)
//IL_03c3: Unknown result type (might be due to invalid IL or missing references)
//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
//IL_03de: Unknown result type (might be due to invalid IL or missing references)
//IL_03e6: Unknown result type (might be due to invalid IL or missing references)
//IL_03ee: Unknown result type (might be due to invalid IL or missing references)
//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
//IL_0408: Unknown result type (might be due to invalid IL or missing references)
//IL_0412: Expected O, but got Unknown
//IL_0415: Unknown result type (might be due to invalid IL or missing references)
//IL_041a: Unknown result type (might be due to invalid IL or missing references)
//IL_0427: Unknown result type (might be due to invalid IL or missing references)
//IL_044e: Unknown result type (might be due to invalid IL or missing references)
//IL_0453: Unknown result type (might be due to invalid IL or missing references)
//IL_045f: Unknown result type (might be due to invalid IL or missing references)
//IL_046b: Unknown result type (might be due to invalid IL or missing references)
//IL_0477: Unknown result type (might be due to invalid IL or missing references)
//IL_0483: Unknown result type (might be due to invalid IL or missing references)
//IL_048f: Unknown result type (might be due to invalid IL or missing references)
//IL_0490: Unknown result type (might be due to invalid IL or missing references)
//IL_049a: Unknown result type (might be due to invalid IL or missing references)
//IL_04a5: Unknown result type (might be due to invalid IL or missing references)
//IL_04b5: Unknown result type (might be due to invalid IL or missing references)
//IL_04c0: Unknown result type (might be due to invalid IL or missing references)
//IL_04c8: Unknown result type (might be due to invalid IL or missing references)
//IL_04d0: Unknown result type (might be due to invalid IL or missing references)
//IL_04d8: Unknown result type (might be due to invalid IL or missing references)
//IL_04e1: Unknown result type (might be due to invalid IL or missing references)
//IL_04e9: Unknown result type (might be due to invalid IL or missing references)
//IL_04f3: Expected O, but got Unknown
//IL_04f6: Unknown result type (might be due to invalid IL or missing references)
//IL_04fb: Unknown result type (might be due to invalid IL or missing references)
//IL_0508: Unknown result type (might be due to invalid IL or missing references)
//IL_052f: Unknown result type (might be due to invalid IL or missing references)
//IL_0534: Unknown result type (might be due to invalid IL or missing references)
//IL_0540: 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_0558: Unknown result type (might be due to invalid IL or missing references)
//IL_0564: Unknown result type (might be due to invalid IL or missing references)
//IL_0570: Unknown result type (might be due to invalid IL or missing references)
//IL_0571: Unknown result type (might be due to invalid IL or missing references)
//IL_057b: Unknown result type (might be due to invalid IL or missing references)
//IL_0586: Unknown result type (might be due to invalid IL or missing references)
//IL_0596: Unknown result type (might be due to invalid IL or missing references)
//IL_05a1: Unknown result type (might be due to invalid IL or missing references)
//IL_05b1: Unknown result type (might be due to invalid IL or missing references)
//IL_05bc: Unknown result type (might be due to invalid IL or missing references)
//IL_05c4: Unknown result type (might be due to invalid IL or missing references)
//IL_05cc: Unknown result type (might be due to invalid IL or missing references)
//IL_05d4: Unknown result type (might be due to invalid IL or missing references)
//IL_05dd: Unknown result type (might be due to invalid IL or missing references)
//IL_05e6: Unknown result type (might be due to invalid IL or missing references)
//IL_05f0: Expected O, but got Unknown
//IL_05f3: Unknown result type (might be due to invalid IL or missing references)
//IL_05f8: Unknown result type (might be due to invalid IL or missing references)
//IL_0605: Unknown result type (might be due to invalid IL or missing references)
Debug.Log((object)"[Armory] Loading Items");
DisableUnwantedTryConnectItems();
Harmony val = new Harmony("armory.mod");
val.PatchAll();
Debug.Log((object)"[Armory] Harmony patches applied");
enableCursedCoin = ((BaseUnityPlugin)this).Config.Bind<bool>("Custom Items", "Cursed Coin", true, "Enable \"cursed coin\" to show up in shop");
enablePills = ((BaseUnityPlugin)this).Config.Bind<bool>("Custom Items", "Experimental Pills", true, "Enable \"experimental pills\" to show up in the shop");
enableBlind = ((BaseUnityPlugin)this).Config.Bind<bool>("Custom Items", "Blind Luck", true, "Enable \"Blind Luck\" to show up in the shop");
enableDoll = ((BaseUnityPlugin)this).Config.Bind<bool>("Custom Items", "Voodoo Doll", true, "Enable \"Voodoo Doll\" to show up in the shop");
enableTaxes = ((BaseUnityPlugin)this).Config.Bind<bool>("Custom Items", "Tax Fraud", true, "Enable \"Tax Fraud\" to show up in the shop");
enableEnergy = ((BaseUnityPlugin)this).Config.Bind<bool>("Custom Items", "Energy Drink", true, "Enable \"Energy Drink\" to show up in the shop");
if (enableCursedCoin.Value)
{
TryConnectBundledItemRegistration val2 = new TryConnectBundledItemRegistration
{
Key = "cursed_coin",
DisplayName = "Cursed Coin",
Description = "Works like a golden chip but with a <color=#BC0508>25% chance to lose 1.5x max bet</color>\n<color=#00ffcc>3 Uses</color>",
BundlePath = "armory.cursed_coin",
VisualPrefabName = "cursed_coin",
VisualLocalScale = Vector3.one * 7.5f,
ApplyVisualColor = false,
ApplyTint = false,
ReplaceColliders = true,
ReplacementChancePercent = 40,
ExtraBasePrice = 1,
ExtraFloorPrice = 1
};
TryConnectRegistrationResult val3 = TryConnectApi.RegisterBundledCustomItem<GoldenChip, CursedCoin>((BaseUnityPlugin)(object)this, val2);
((BaseUnityPlugin)this).Logger.LogInfo((object)$"TryConnect register result for cursed_coin: {val3}");
}
if (enablePills.Value)
{
TryConnectBundledItemRegistration val4 = new TryConnectBundledItemRegistration
{
Key = "exp_pills",
DisplayName = "Experimental Pills",
Description = "<color=#00ffcc>70%</color> to gain a body part\n<color=#BC0508>30%</color> to lose a body part",
BundlePath = "armory.pills",
VisualPrefabName = "pills",
VisualLocalScale = Vector3.one * 0.32f,
ApplyVisualColor = false,
ApplyTint = false,
ReplaceColliders = true,
ReplacementChancePercent = 25,
ExtraBasePrice = 4,
ExtraFloorPrice = -1
};
TryConnectRegistrationResult val5 = TryConnectApi.RegisterBundledCustomItem<Upgrade, Experimental_Pills>((BaseUnityPlugin)(object)this, val4);
((BaseUnityPlugin)this).Logger.LogInfo((object)$"TryConnect register result for exp_pills: {val5}");
}
if (enableBlind.Value)
{
TryConnectBundledItemRegistration val6 = new TryConnectBundledItemRegistration
{
Key = "blind_eyes",
DisplayName = "Blind Luck",
Description = "<color=#BC0508>Lose</color> both your eyes\n<color=#23e82e>Gain</color> bonus income for the day",
BundlePath = "armory.scooper",
VisualPrefabName = "scooper",
VisualLocalScale = Vector3.one * 0.13f,
VisualLocalEulerAngles = new Vector3(-90f, 0f, 180f),
ApplyVisualColor = false,
ApplyTint = false,
ReplaceColliders = true,
ReplacementChancePercent = 35,
ExtraBasePrice = -3,
ExtraFloorPrice = 0
};
TryConnectRegistrationResult val7 = TryConnectApi.RegisterBundledCustomItem<Drink, BlindLuck>((BaseUnityPlugin)(object)this, val6);
((BaseUnityPlugin)this).Logger.LogInfo((object)$"TryConnect register result for blind_eyes: {val7}");
}
if (enableDoll.Value)
{
TryConnectBundledItemRegistration val8 = new TryConnectBundledItemRegistration
{
Key = "voodoo_doll",
DisplayName = "Voodoo Doll",
Description = "<color=#BC0508>80%</color> to lose all body parts\n<color=#23e82e>20%</color> to earn quota",
BundlePath = "armory.doll",
VisualPrefabName = "doll",
VisualLocalScale = Vector3.one * 0.15f,
VisualLocalEulerAngles = new Vector3(0f, -90f, 0f),
ApplyVisualColor = false,
ApplyTint = false,
ReplaceColliders = true,
ReplacementChancePercent = 45,
ExtraBasePrice = -3,
ExtraFloorPrice = -1
};
TryConnectRegistrationResult val9 = TryConnectApi.RegisterBundledCustomItem<Coordinator, VoodooDoll>((BaseUnityPlugin)(object)this, val8);
((BaseUnityPlugin)this).Logger.LogInfo((object)$"TryConnect register result for voodoo_doll: {val9}");
}
if (enableTaxes.Value)
{
TryConnectBundledItemRegistration val10 = new TryConnectBundledItemRegistration
{
Key = "taxes",
DisplayName = "Tax Fraud",
Description = "<color=#23e82e>Decrease</color> quota by 20%\n<color=#BC0508>5%</color> chance to get audited",
BundlePath = "armory.taxes",
VisualPrefabName = "taxes",
VisualLocalScale = Vector3.one * 0.015f,
VisualLocalEulerAngles = new Vector3(50f, 180f, -180f),
ApplyVisualColor = false,
ApplyTint = false,
ReplaceColliders = true,
ReplacementChancePercent = 25,
ExtraBasePrice = 1,
ExtraFloorPrice = 3
};
TryConnectRegistrationResult val11 = TryConnectApi.RegisterBundledCustomItem<Taser, TaxFraud>((BaseUnityPlugin)(object)this, val10);
((BaseUnityPlugin)this).Logger.LogInfo((object)$"TryConnect register result for taxes: {val11}");
}
if (enableTaxes.Value)
{
TryConnectBundledItemRegistration val12 = new TryConnectBundledItemRegistration
{
Key = "energy_drink",
DisplayName = "Energy Drink",
Description = "Makes wheels on the floor spin <color=#23e82e>3x</color> as fast for 90 seconds",
BundlePath = "armory.energy_drink",
VisualPrefabName = "energy_drink",
VisualLocalScale = Vector3.one * 0.18f,
VisualLocalEulerAngles = new Vector3(-90f, -90f, 0f),
VisualLocalPosition = new Vector3(0f, -0.3f, 0f),
ApplyVisualColor = false,
ApplyTint = false,
ReplaceColliders = true,
ReplacementChancePercent = 45,
ExtraBasePrice = -2,
ExtraFloorPrice = -1
};
TryConnectRegistrationResult val13 = TryConnectApi.RegisterBundledCustomItem<Microphone, EnergyDrink>((BaseUnityPlugin)(object)this, val12);
((BaseUnityPlugin)this).Logger.LogInfo((object)$"TryConnect register result for energy drink: {val13}");
}
}
private void DisableUnwantedTryConnectItems()
{
try
{
string path = Path.Combine(Paths.ConfigPath, "com.Try-4646.TryConnect.cfg");
if (!File.Exists(path))
{
return;
}
Debug.Log((object)"[Armory] Found TryConnect config file, ensuring Ticket Fizz and Loaded Chip are disabled");
string[] array = File.ReadAllLines(path);
bool flag = false;
for (int i = 0; i < array.Length; i++)
{
if (array[i].StartsWith("TicketFizzReplacementChance ="))
{
string text = array[i];
array[i] = "TicketFizzReplacementChance = 0";
if (text != array[i])
{
flag = true;
Debug.Log((object)"[Armory] Set TicketFizzReplacementChance to 0");
}
}
if (array[i].StartsWith("LoadedChipReplacementChance ="))
{
string text2 = array[i];
array[i] = "LoadedChipReplacementChance = 0";
if (text2 != array[i])
{
flag = true;
Debug.Log((object)"[Armory] Set LoadedChipReplacementChance to 0");
}
}
}
if (flag)
{
File.WriteAllLines(path, array);
Debug.Log((object)"[Armory] Successfully disabled unwanted TryConnect items");
}
else
{
Debug.Log((object)"[Armory] TryConnect items already disabled");
}
}
catch (Exception ex)
{
Debug.LogError((object)("[Armory] Failed to modify TryConnect config: " + ex.Message));
}
}
}
namespace Items_Mod_For_Gamble.Patches
{
[HarmonyPatch(typeof(Coordinator), "OnUseItem")]
public static class CoordinatorPatch
{
[CompilerGenerated]
private sealed class <DollRoutine>d__1 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public Coordinator doll;
private PlayerOrgans <organs>5__1;
private PlayerProfile <profile>5__2;
private bool <leftEye>5__3;
private bool <rightEye>5__4;
private bool <body>5__5;
private bool <mouth>5__6;
private OrganManager <mgr>5__7;
private float <roll>5__8;
private float <multiplier>5__9;
private long <gainAmount>5__10;
private MoneyManager <money>5__11;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <DollRoutine>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<organs>5__1 = null;
<profile>5__2 = null;
<mgr>5__7 = null;
<money>5__11 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(0.5f);
<>1__state = 1;
return true;
case 1:
{
<>1__state = -1;
if (!NetworkServer.active)
{
return false;
}
Scene activeScene = SceneManager.GetActiveScene();
if (((Scene)(ref activeScene)).name == "HomeScene")
{
((ConsumableItem)doll).DestroyItem();
return false;
}
PlayerInventory networkHolder = ((Item)doll).NetworkHolder;
<organs>5__1 = ((networkHolder != null) ? ((Component)networkHolder).GetComponent<PlayerOrgans>() : null);
PlayerInventory networkHolder2 = ((Item)doll).NetworkHolder;
<profile>5__2 = ((networkHolder2 != null) ? ((Component)networkHolder2).GetComponent<PlayerProfile>() : null);
if ((Object)(object)<organs>5__1 == (Object)null || (Object)(object)<profile>5__2 == (Object)null)
{
return false;
}
<leftEye>5__3 = UpgradePatch.GetField(<organs>5__1, "_localLeftEye");
<rightEye>5__4 = UpgradePatch.GetField(<organs>5__1, "_localRightEye");
<body>5__5 = UpgradePatch.GetField(<organs>5__1, "_localBody");
<mouth>5__6 = UpgradePatch.GetField(<organs>5__1, "_localMouth");
if (!<leftEye>5__3 && !<rightEye>5__4 && !<body>5__5 && !<mouth>5__6)
{
return false;
}
<mgr>5__7 = NetworkSingleton<OrganManager>.Instance;
<roll>5__8 = Random.value;
if (<roll>5__8 <= 0.8f)
{
<mgr>5__7.ServerToggleOrgan(<organs>5__1, (OrganType)0, false);
<mgr>5__7.ServerToggleOrgan(<organs>5__1, (OrganType)1, false);
<mgr>5__7.ServerToggleOrgan(<organs>5__1, (OrganType)2, false);
<mgr>5__7.ServerToggleOrgan(<organs>5__1, (OrganType)3, false);
}
else
{
<multiplier>5__9 = NetworkSingleton<UpgradeManager>.Instance.GetUpgradeData(<profile>5__2.steamId, (PlayerUpgradeType)2);
<gainAmount>5__10 = (long)((float)NetworkSingleton<GameManager>.Instance.currentQuota * <multiplier>5__9);
<money>5__11 = NetworkSingleton<MoneyManager>.Instance;
if ((Object)(object)<money>5__11 != (Object)null)
{
<money>5__11.TryChangeBalance(<gainAmount>5__10, <profile>5__2, (ChangeType)4);
}
<money>5__11 = null;
}
((ConsumableItem)doll).DestroyItem();
return false;
}
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[HarmonyPrefix]
public static bool Prefix(Coordinator __instance, bool isPressed)
{
string text = ((Object)((Component)__instance).gameObject).name.ToLower();
if (text.Contains("voodoo doll"))
{
((MonoBehaviour)__instance).StartCoroutine(DollRoutine(__instance));
return false;
}
return true;
}
[IteratorStateMachine(typeof(<DollRoutine>d__1))]
private static IEnumerator DollRoutine(Coordinator doll)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <DollRoutine>d__1(0)
{
doll = doll
};
}
}
[HarmonyPatch(typeof(Drink), "OnUseItem")]
public static class DrinkPatch
{
[CompilerGenerated]
private sealed class <BlindRoutine>d__5 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public Drink drink;
private PlayerOrgans <organs>5__1;
private OrganManager <mgr>5__2;
private PlayerProfile <profile>5__3;
private PlayerBuff <buff>5__4;
private float <multiplier>5__5;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <BlindRoutine>d__5(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<organs>5__1 = null;
<mgr>5__2 = null;
<profile>5__3 = null;
<buff>5__4 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(1f);
<>1__state = 1;
return true;
case 1:
{
<>1__state = -1;
if (!NetworkServer.active)
{
return false;
}
PlayerInventory networkHolder = ((Item)drink).NetworkHolder;
<organs>5__1 = ((networkHolder != null) ? ((Component)networkHolder).GetComponent<PlayerOrgans>() : null);
if ((Object)(object)<organs>5__1 == (Object)null)
{
return false;
}
NetworkSingleton<OrganManager>.Instance.ServerToggleOrgan(<organs>5__1, (OrganType)0, false);
NetworkSingleton<OrganManager>.Instance.ServerToggleOrgan(<organs>5__1, (OrganType)1, false);
<mgr>5__2 = NetworkSingleton<OrganManager>.Instance;
<mgr>5__2.ServerToggleOrgan(<organs>5__1, (OrganType)0, false);
<mgr>5__2.ServerToggleOrgan(<organs>5__1, (OrganType)1, false);
PlayerInventory networkHolder2 = ((Item)drink).NetworkHolder;
<profile>5__3 = ((networkHolder2 != null) ? ((Component)networkHolder2).GetComponent<PlayerProfile>() : null);
PlayerInventory networkHolder3 = ((Item)drink).NetworkHolder;
<buff>5__4 = ((networkHolder3 != null) ? ((Component)networkHolder3).GetComponent<PlayerBuff>() : null);
if ((Object)(object)<profile>5__3 != (Object)null && (Object)(object)<buff>5__4 != (Object)null)
{
<multiplier>5__5 = NetworkSingleton<UpgradeManager>.Instance.GetUpgradeData(<profile>5__3.steamId, (PlayerUpgradeType)2);
<buff>5__4.ApplyBuff((PlayerBuffType)0, 1.5f * <multiplier>5__5, 9999f);
}
((ConsumableItem)drink).DestroyItem();
return false;
}
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private static readonly FieldRef<Drink, Animator> AnimRef = AccessTools.FieldRefAccess<Drink, Animator>("anim");
private static readonly FieldRef<Drink, SFXComponent> CantDrinkSfxRef = AccessTools.FieldRefAccess<Drink, SFXComponent>("cantDrinkSfx");
private static readonly FieldRef<Drink, Coroutine> DrinkRoutineRef = AccessTools.FieldRefAccess<Drink, Coroutine>("_drinkRoutine");
[HarmonyPrefix]
public static bool Prefix(Drink __instance, bool isPressed)
{
string text = ((Object)((Component)__instance).gameObject).name.ToLower();
if (text.Contains("blind luck"))
{
BlindUse(__instance, isPressed);
return false;
}
return true;
}
private static void BlindUse(Drink drink, bool isPressed)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
Scene activeScene = SceneManager.GetActiveScene();
if (((Scene)(ref activeScene)).name == "HomeScene")
{
((ConsumableItem)drink).DestroyItem();
return;
}
PlayerInventory networkHolder = ((Item)drink).NetworkHolder;
PlayerOrgans val = ((networkHolder != null) ? ((Component)networkHolder).GetComponent<PlayerOrgans>() : null);
if ((Object)(object)val == (Object)null)
{
return;
}
bool field = UpgradePatch.GetField(val, "_localLeftEye");
bool field2 = UpgradePatch.GetField(val, "_localRightEye");
if (!field || !field2)
{
SFXComponent obj = CantDrinkSfxRef.Invoke(drink);
if (obj != null)
{
obj.PlayOneShotAttached();
}
return;
}
AnimRef.Invoke(drink).SetBool("IsDrinking", isPressed);
if (NetworkServer.active)
{
Coroutine val2 = DrinkRoutineRef.Invoke(drink);
if (val2 != null)
{
((MonoBehaviour)drink).StopCoroutine(val2);
}
if (isPressed)
{
Coroutine val3 = ((MonoBehaviour)drink).StartCoroutine(BlindRoutine(drink));
DrinkRoutineRef.Invoke(drink) = val3;
}
}
}
[IteratorStateMachine(typeof(<BlindRoutine>d__5))]
private static IEnumerator BlindRoutine(Drink drink)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <BlindRoutine>d__5(0)
{
drink = drink
};
}
}
[HarmonyPatch(typeof(Microphone), "OnUseItem")]
public static class MicrophoneSpeedBoostPatch
{
[HarmonyPatch(typeof(Microphone), "OnPickedUp")]
public static class MicrophonePickupPatch
{
[HarmonyPrefix]
public static bool Prefix(Microphone __instance, PlayerInventory playerInventory)
{
string text = ((Object)((Component)__instance).gameObject).name.ToLower();
if (text.Contains("energy drink"))
{
return false;
}
return true;
}
}
[CompilerGenerated]
private sealed class <EnergyDrinkRoutine>d__5 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public float stakeholderMultiplier;
private float <finalSpeedMultiplier>5__1;
private float <finalDuration>5__2;
private float <effectiveMultiplier>5__3;
private Dictionary<Slots, (float duration, int count)> <slotsOriginalValues>5__4;
private Dictionary<Wheel, float> <wheelOriginalDurations>5__5;
private Dictionary<RouletteWheel, float> <rouletteOriginalDurations>5__6;
private Dictionary<RouletteWheel, float> <rouletteOriginalBallDropDurations>5__7;
private Slots[] <allSlots>5__8;
private Wheel[] <allWheels>5__9;
private RouletteWheel[] <allRouletteWheels>5__10;
private float <startTime>5__11;
private Slots[] <>s__12;
private int <>s__13;
private Slots <slot>5__14;
private FieldInfo <durationField>5__15;
private FieldInfo <countField>5__16;
private float <originalDuration>5__17;
private int <originalCount>5__18;
private float <newDuration>5__19;
private int <newCount>5__20;
private Wheel[] <>s__21;
private int <>s__22;
private Wheel <wheel>5__23;
private FieldInfo <spinDurationField>5__24;
private float <originalDuration>5__25;
private float <newDuration>5__26;
private RouletteWheel[] <>s__27;
private int <>s__28;
private RouletteWheel <wheel>5__29;
private FieldInfo <spinDurationField>5__30;
private FieldInfo <ballDropDurationField>5__31;
private float <originalSpinDuration>5__32;
private float <newSpinDuration>5__33;
private float <originalBallDropDuration>5__34;
private float <newBallDropDuration>5__35;
private Dictionary<Slots, (float duration, int count)>.Enumerator <>s__36;
private KeyValuePair<Slots, (float duration, int count)> <kvp>5__37;
private FieldInfo <durationField>5__38;
private FieldInfo <countField>5__39;
private Dictionary<Wheel, float>.Enumerator <>s__40;
private KeyValuePair<Wheel, float> <kvp>5__41;
private FieldInfo <spinDurationField>5__42;
private Dictionary<RouletteWheel, float>.Enumerator <>s__43;
private KeyValuePair<RouletteWheel, float> <kvp>5__44;
private FieldInfo <spinDurationField>5__45;
private Dictionary<RouletteWheel, float>.Enumerator <>s__46;
private KeyValuePair<RouletteWheel, float> <kvp>5__47;
private FieldInfo <ballDropDurationField>5__48;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <EnergyDrinkRoutine>d__5(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<slotsOriginalValues>5__4 = null;
<wheelOriginalDurations>5__5 = null;
<rouletteOriginalDurations>5__6 = null;
<rouletteOriginalBallDropDurations>5__7 = null;
<allSlots>5__8 = null;
<allWheels>5__9 = null;
<allRouletteWheels>5__10 = null;
<>s__12 = null;
<slot>5__14 = null;
<durationField>5__15 = null;
<countField>5__16 = null;
<>s__21 = null;
<wheel>5__23 = null;
<spinDurationField>5__24 = null;
<>s__27 = null;
<wheel>5__29 = null;
<spinDurationField>5__30 = null;
<ballDropDurationField>5__31 = null;
<>s__36 = default(Dictionary<Slots, (float, int)>.Enumerator);
<kvp>5__37 = default(KeyValuePair<Slots, (float, int)>);
<durationField>5__38 = null;
<countField>5__39 = null;
<>s__40 = default(Dictionary<Wheel, float>.Enumerator);
<kvp>5__41 = default(KeyValuePair<Wheel, float>);
<spinDurationField>5__42 = null;
<>s__43 = default(Dictionary<RouletteWheel, float>.Enumerator);
<kvp>5__44 = default(KeyValuePair<RouletteWheel, float>);
<spinDurationField>5__45 = null;
<>s__46 = default(Dictionary<RouletteWheel, float>.Enumerator);
<kvp>5__47 = default(KeyValuePair<RouletteWheel, float>);
<ballDropDurationField>5__48 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Expected O, but got Unknown
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_05db: Unknown result type (might be due to invalid IL or missing references)
//IL_05e5: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(0.1f);
<>1__state = 1;
return true;
case 1:
{
<>1__state = -1;
Scene activeScene = SceneManager.GetActiveScene();
if (((Scene)(ref activeScene)).name == "HomeScene")
{
return false;
}
<finalSpeedMultiplier>5__1 = _speedMultiplier * stakeholderMultiplier;
<finalDuration>5__2 = _boostDuration;
<effectiveMultiplier>5__3 = <finalSpeedMultiplier>5__1;
<slotsOriginalValues>5__4 = new Dictionary<Slots, (float, int)>();
<wheelOriginalDurations>5__5 = new Dictionary<Wheel, float>();
<rouletteOriginalDurations>5__6 = new Dictionary<RouletteWheel, float>();
<rouletteOriginalBallDropDurations>5__7 = new Dictionary<RouletteWheel, float>();
<allSlots>5__8 = Object.FindObjectsByType<Slots>((FindObjectsSortMode)0);
<>s__12 = <allSlots>5__8;
for (<>s__13 = 0; <>s__13 < <>s__12.Length; <>s__13++)
{
<slot>5__14 = <>s__12[<>s__13];
if ((Object)(object)<slot>5__14 != (Object)null)
{
<durationField>5__15 = typeof(Slots).GetField("spinDuration", BindingFlags.Instance | BindingFlags.NonPublic);
<countField>5__16 = typeof(Slots).GetField("spinCount", BindingFlags.Instance | BindingFlags.NonPublic);
if (<durationField>5__15 != null && <countField>5__16 != null)
{
<originalDuration>5__17 = (float)<durationField>5__15.GetValue(<slot>5__14);
<originalCount>5__18 = (int)<countField>5__16.GetValue(<slot>5__14);
<slotsOriginalValues>5__4[<slot>5__14] = (<originalDuration>5__17, <originalCount>5__18);
<newDuration>5__19 = <originalDuration>5__17 / <effectiveMultiplier>5__3;
<newCount>5__20 = Mathf.RoundToInt((float)<originalCount>5__18 * <effectiveMultiplier>5__3);
<newDuration>5__19 = Mathf.Clamp(<newDuration>5__19, 0.5f, 10f);
<newCount>5__20 = Mathf.Clamp(<newCount>5__20, 5, 100);
<durationField>5__15.SetValue(<slot>5__14, <newDuration>5__19);
<countField>5__16.SetValue(<slot>5__14, <newCount>5__20);
}
<durationField>5__15 = null;
<countField>5__16 = null;
}
<slot>5__14 = null;
}
<>s__12 = null;
<allWheels>5__9 = Object.FindObjectsByType<Wheel>((FindObjectsSortMode)0);
<>s__21 = <allWheels>5__9;
for (<>s__22 = 0; <>s__22 < <>s__21.Length; <>s__22++)
{
<wheel>5__23 = <>s__21[<>s__22];
if ((Object)(object)<wheel>5__23 != (Object)null)
{
<spinDurationField>5__24 = typeof(Wheel).GetField("spinDuration", BindingFlags.Instance | BindingFlags.NonPublic);
if (<spinDurationField>5__24 != null)
{
<originalDuration>5__25 = (float)<spinDurationField>5__24.GetValue(<wheel>5__23);
<wheelOriginalDurations>5__5[<wheel>5__23] = <originalDuration>5__25;
<newDuration>5__26 = <originalDuration>5__25 / <effectiveMultiplier>5__3;
<newDuration>5__26 = Mathf.Clamp(<newDuration>5__26, 1f, 10f);
<spinDurationField>5__24.SetValue(<wheel>5__23, <newDuration>5__26);
}
<spinDurationField>5__24 = null;
}
<wheel>5__23 = null;
}
<>s__21 = null;
<allRouletteWheels>5__10 = Object.FindObjectsByType<RouletteWheel>((FindObjectsSortMode)0);
<>s__27 = <allRouletteWheels>5__10;
for (<>s__28 = 0; <>s__28 < <>s__27.Length; <>s__28++)
{
<wheel>5__29 = <>s__27[<>s__28];
if ((Object)(object)<wheel>5__29 != (Object)null)
{
<spinDurationField>5__30 = typeof(Wheel).GetField("spinDuration", BindingFlags.Instance | BindingFlags.NonPublic);
<ballDropDurationField>5__31 = typeof(RouletteWheel).GetField("ballDropDuration", BindingFlags.Instance | BindingFlags.NonPublic);
if (<spinDurationField>5__30 != null)
{
<originalSpinDuration>5__32 = (float)<spinDurationField>5__30.GetValue(<wheel>5__29);
<rouletteOriginalDurations>5__6[<wheel>5__29] = <originalSpinDuration>5__32;
<newSpinDuration>5__33 = <originalSpinDuration>5__32 / <effectiveMultiplier>5__3;
<newSpinDuration>5__33 = Mathf.Clamp(<newSpinDuration>5__33, 1f, 15f);
<spinDurationField>5__30.SetValue(<wheel>5__29, <newSpinDuration>5__33);
}
if (<ballDropDurationField>5__31 != null)
{
<originalBallDropDuration>5__34 = (float)<ballDropDurationField>5__31.GetValue(<wheel>5__29);
<rouletteOriginalBallDropDurations>5__7[<wheel>5__29] = <originalBallDropDuration>5__34;
<newBallDropDuration>5__35 = <originalBallDropDuration>5__34 / <effectiveMultiplier>5__3;
<newBallDropDuration>5__35 = Mathf.Clamp(<newBallDropDuration>5__35, 0.3f, 3f);
<ballDropDurationField>5__31.SetValue(<wheel>5__29, <newBallDropDuration>5__35);
}
<spinDurationField>5__30 = null;
<ballDropDurationField>5__31 = null;
}
<wheel>5__29 = null;
}
<>s__27 = null;
<startTime>5__11 = Time.time;
break;
}
case 2:
<>1__state = -1;
break;
}
if (Time.time - <startTime>5__11 < <finalDuration>5__2)
{
<>2__current = (object)new WaitForSeconds(1f);
<>1__state = 2;
return true;
}
<>s__36 = <slotsOriginalValues>5__4.GetEnumerator();
try
{
while (<>s__36.MoveNext())
{
<kvp>5__37 = <>s__36.Current;
if ((Object)(object)<kvp>5__37.Key != (Object)null)
{
<durationField>5__38 = typeof(Slots).GetField("spinDuration", BindingFlags.Instance | BindingFlags.NonPublic);
<countField>5__39 = typeof(Slots).GetField("spinCount", BindingFlags.Instance | BindingFlags.NonPublic);
if (<durationField>5__38 != null && <countField>5__39 != null)
{
<durationField>5__38.SetValue(<kvp>5__37.Key, <kvp>5__37.Value.duration);
<countField>5__39.SetValue(<kvp>5__37.Key, <kvp>5__37.Value.count);
}
<durationField>5__38 = null;
<countField>5__39 = null;
}
<kvp>5__37 = default(KeyValuePair<Slots, (float, int)>);
}
}
finally
{
((IDisposable)<>s__36).Dispose();
}
<>s__36 = default(Dictionary<Slots, (float, int)>.Enumerator);
<>s__40 = <wheelOriginalDurations>5__5.GetEnumerator();
try
{
while (<>s__40.MoveNext())
{
<kvp>5__41 = <>s__40.Current;
if ((Object)(object)<kvp>5__41.Key != (Object)null)
{
<spinDurationField>5__42 = typeof(Wheel).GetField("spinDuration", BindingFlags.Instance | BindingFlags.NonPublic);
if (<spinDurationField>5__42 != null)
{
<spinDurationField>5__42.SetValue(<kvp>5__41.Key, <kvp>5__41.Value);
}
<spinDurationField>5__42 = null;
}
<kvp>5__41 = default(KeyValuePair<Wheel, float>);
}
}
finally
{
((IDisposable)<>s__40).Dispose();
}
<>s__40 = default(Dictionary<Wheel, float>.Enumerator);
<>s__43 = <rouletteOriginalDurations>5__6.GetEnumerator();
try
{
while (<>s__43.MoveNext())
{
<kvp>5__44 = <>s__43.Current;
if ((Object)(object)<kvp>5__44.Key != (Object)null)
{
<spinDurationField>5__45 = typeof(Wheel).GetField("spinDuration", BindingFlags.Instance | BindingFlags.NonPublic);
if (<spinDurationField>5__45 != null)
{
<spinDurationField>5__45.SetValue(<kvp>5__44.Key, <kvp>5__44.Value);
}
<spinDurationField>5__45 = null;
}
<kvp>5__44 = default(KeyValuePair<RouletteWheel, float>);
}
}
finally
{
((IDisposable)<>s__43).Dispose();
}
<>s__43 = default(Dictionary<RouletteWheel, float>.Enumerator);
<>s__46 = <rouletteOriginalBallDropDurations>5__7.GetEnumerator();
try
{
while (<>s__46.MoveNext())
{
<kvp>5__47 = <>s__46.Current;
if ((Object)(object)<kvp>5__47.Key != (Object)null)
{
<ballDropDurationField>5__48 = typeof(RouletteWheel).GetField("ballDropDuration", BindingFlags.Instance | BindingFlags.NonPublic);
if (<ballDropDurationField>5__48 != null)
{
<ballDropDurationField>5__48.SetValue(<kvp>5__47.Key, <kvp>5__47.Value);
}
<ballDropDurationField>5__48 = null;
}
<kvp>5__47 = default(KeyValuePair<RouletteWheel, float>);
}
}
finally
{
((IDisposable)<>s__46).Dispose();
}
<>s__46 = default(Dictionary<RouletteWheel, float>.Enumerator);
_activeBoostCoroutine = null;
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private static float _speedMultiplier = 3f;
private static float _boostDuration = 90f;
private static Coroutine _activeBoostCoroutine = null;
[HarmonyPrefix]
public static bool Prefix(Microphone __instance, bool isPressed)
{
string text = ((Object)((Component)__instance).gameObject).name.ToLower();
if (text.Contains("energy drink"))
{
if (isPressed && NetworkServer.active)
{
PlayerInventory networkHolder = ((Item)__instance).NetworkHolder;
PlayerProfile val = ((networkHolder != null) ? ((Component)networkHolder).GetComponent<PlayerProfile>() : null);
float stakeholderMultiplier = 1f;
if ((Object)(object)val != (Object)null)
{
stakeholderMultiplier = NetworkSingleton<UpgradeManager>.Instance.GetUpgradeData(val.steamId, (PlayerUpgradeType)2);
}
if (_activeBoostCoroutine != null)
{
GameManager instance = NetworkSingleton<GameManager>.Instance;
if (instance != null)
{
((MonoBehaviour)instance).StopCoroutine(_activeBoostCoroutine);
}
}
GameManager instance2 = NetworkSingleton<GameManager>.Instance;
_activeBoostCoroutine = ((instance2 != null) ? ((MonoBehaviour)instance2).StartCoroutine(EnergyDrinkRoutine(stakeholderMultiplier)) : null);
((ConsumableItem)__instance).DestroyItem();
}
return false;
}
return true;
}
[IteratorStateMachine(typeof(<EnergyDrinkRoutine>d__5))]
private static IEnumerator EnergyDrinkRoutine(float stakeholderMultiplier)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <EnergyDrinkRoutine>d__5(0)
{
stakeholderMultiplier = stakeholderMultiplier
};
}
}
[HarmonyPatch(typeof(MysteryBox), "GetRandomSpawnableByWeight")]
public static class MysteryBoxIncludeModdedItemsPatch
{
private static List<SpawnableSO> _cachedModdedSpawnables;
private static MethodInfo _getSeededRandomMethod;
static MysteryBoxIncludeModdedItemsPatch()
{
CacheModdedSpawnables();
_getSeededRandomMethod = AccessTools.Method(typeof(MysteryBox), "GetSeededRandom", (Type[])null, (Type[])null);
}
private static void CacheModdedSpawnables()
{
_cachedModdedSpawnables = new List<SpawnableSO>();
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (Assembly assembly in assemblies)
{
if (!assembly.GetName().Name.Contains("TryConnect"))
{
continue;
}
Type type = assembly.GetType("TryConnect.RuntimeItemRegistry");
if (!(type != null))
{
continue;
}
MethodInfo methodInfo = AccessTools.Method(type, "GetRegisteredItemInfos", (Type[])null, (Type[])null);
if (!(methodInfo != null) || !(methodInfo.Invoke(null, null) is Array array))
{
break;
}
foreach (object item in array)
{
PropertyInfo property = item.GetType().GetProperty("Spawnable");
PropertyInfo property2 = item.GetType().GetProperty("IsRegistered");
if (property != null && property2 != null)
{
bool flag = (bool)property2.GetValue(item);
object? value = property.GetValue(item);
SpawnableSO val = (SpawnableSO)((value is SpawnableSO) ? value : null);
if (flag && (Object)(object)val != (Object)null && !val.spawnableName.Contains("Ticket Fizz") && !val.spawnableName.Contains("Loaded Chip"))
{
_cachedModdedSpawnables.Add(val);
}
}
}
break;
}
Debug.Log((object)$"[Armory] Cached {_cachedModdedSpawnables.Count} modded items for Mystery Box");
}
[HarmonyPrefix]
public static bool Prefix(MysteryBox __instance, ref SpawnableSO __result)
{
//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
//IL_0149: Unknown result type (might be due to invalid IL or missing references)
//IL_014e: Unknown result type (might be due to invalid IL or missing references)
//IL_0153: Unknown result type (might be due to invalid IL or missing references)
//IL_0171: Unknown result type (might be due to invalid IL or missing references)
//IL_017e: Unknown result type (might be due to invalid IL or missing references)
FieldInfo fieldInfo = AccessTools.Field(typeof(MysteryBox), "spawnableList");
if (!(fieldInfo.GetValue(__instance) is List<SpawnableEntry> list) || list.Count == 0)
{
return true;
}
if (_cachedModdedSpawnables != null && _cachedModdedSpawnables.Count > 0)
{
List<SpawnableEntry> list2 = new List<SpawnableEntry>();
list2.AddRange(list);
float num = list.Average((SpawnableEntry e) => e.chanceWeight);
foreach (SpawnableSO cachedModdedSpawnable in _cachedModdedSpawnables)
{
list2.Add(new SpawnableEntry
{
spawnable = cachedModdedSpawnable,
chanceWeight = num * 2f
});
}
float num2 = list2.Sum((SpawnableEntry e) => e.chanceWeight);
Random random = _getSeededRandomMethod.Invoke(__instance, null) as Random;
float num3 = (float)random.NextDouble() * num2;
foreach (SpawnableEntry item in list2)
{
num3 -= item.chanceWeight;
if (num3 <= 0f)
{
__result = item.spawnable;
Debug.Log((object)("[Armory] Mystery Box selected: " + item.spawnable.spawnableName));
return false;
}
}
}
return true;
}
}
[HarmonyPatch(typeof(Taser), "OnUseItem")]
public static class TaserPatch
{
[CompilerGenerated]
private sealed class <TaxesRoutine>d__1 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public Taser taxes;
private PlayerProfile <profile>5__1;
private float <roll>5__2;
private float <multiplier>5__3;
private long <removeAmount>5__4;
private MoneyManager <money>5__5;
private GameManager <gm>5__6;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <TaxesRoutine>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<profile>5__1 = null;
<money>5__5 = null;
<gm>5__6 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(0.1f);
<>1__state = 1;
return true;
case 1:
{
<>1__state = -1;
if (!NetworkServer.active)
{
return false;
}
Scene activeScene = SceneManager.GetActiveScene();
if (((Scene)(ref activeScene)).name == "HomeScene")
{
((ConsumableItem)taxes).DestroyItem();
return false;
}
PlayerInventory networkHolder = ((Item)taxes).NetworkHolder;
<profile>5__1 = ((networkHolder != null) ? ((Component)networkHolder).GetComponent<PlayerProfile>() : null);
<roll>5__2 = Random.value;
<multiplier>5__3 = NetworkSingleton<UpgradeManager>.Instance.GetUpgradeData(<profile>5__1.steamId, (PlayerUpgradeType)2);
<removeAmount>5__4 = (long)((float)NetworkSingleton<GameManager>.Instance.currentQuota * Mathf.Clamp(<multiplier>5__3 * 0.2f, 0.2f, 0.75f));
<money>5__5 = NetworkSingleton<MoneyManager>.Instance;
<gm>5__6 = NetworkSingleton<GameManager>.Instance;
<gm>5__6.NetworkcurrentQuota = Math.Max(0L, <gm>5__6.NetworkcurrentQuota - <removeAmount>5__4);
if ((double)<roll>5__2 <= 0.05)
{
<money>5__5.TryChangeBalance(-NetworkSingleton<MoneyManager>.Instance.balance, <profile>5__1, (ChangeType)4);
}
RefreshAllKeypadMinMaxBetTexts();
((ConsumableItem)taxes).DestroyItem();
return false;
}
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[HarmonyPrefix]
public static bool Prefix(Taser __instance, bool isPressed)
{
string text = ((Object)((Component)__instance).gameObject).name.ToLower();
if (text.Contains("tax fraud"))
{
((MonoBehaviour)__instance).StartCoroutine(TaxesRoutine(__instance));
return false;
}
return true;
}
[IteratorStateMachine(typeof(<TaxesRoutine>d__1))]
private static IEnumerator TaxesRoutine(Taser taxes)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <TaxesRoutine>d__1(0)
{
taxes = taxes
};
}
private static void RefreshAllKeypadMinMaxBetTexts()
{
Keypad[] array = Object.FindObjectsByType<Keypad>((FindObjectsSortMode)0);
Keypad[] array2 = array;
foreach (Keypad val in array2)
{
if ((Object)(object)val != (Object)null && ((Behaviour)val).isActiveAndEnabled && (Object)(object)val.NetworkcasinoGame != (Object)null)
{
long minBet = val.NetworkcasinoGame.MinBet;
long maxBet = val.NetworkcasinoGame.MaxBet;
val.ServerUpdateMinMaxBetText(minBet, maxBet);
}
}
}
}
[HarmonyPatch(typeof(Upgrade), "UseRoutine")]
public static class UpgradePatch
{
[CompilerGenerated]
private sealed class <PillsRoutine>d__1 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public Upgrade item;
private PlayerOrgans <organs>5__1;
private PlayerOrganData <state>5__2;
private bool <hasMissing>5__3;
private float <roll>5__4;
private OrganManager <mgr>5__5;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <PillsRoutine>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<organs>5__1 = null;
<state>5__2 = null;
<mgr>5__5 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSecondsRealtime(0.05f);
<>1__state = 1;
return true;
case 1:
{
<>1__state = -1;
Scene activeScene = SceneManager.GetActiveScene();
if (((Scene)(ref activeScene)).name == "HomeScene")
{
((ConsumableItem)item).DestroyItem();
return false;
}
if (!NetworkServer.active)
{
return false;
}
PlayerInventory networkHolder = ((Item)item).NetworkHolder;
<organs>5__1 = ((networkHolder != null) ? ((Component)networkHolder).GetComponent<PlayerOrgans>() : null);
if ((Object)(object)<organs>5__1 == (Object)null)
{
return false;
}
<state>5__2 = GetCurrentState(<organs>5__1);
<hasMissing>5__3 = !<state>5__2.leftEye || !<state>5__2.rightEye || !<state>5__2.body || !<state>5__2.mouth;
if (!<hasMissing>5__3)
{
return false;
}
<roll>5__4 = Random.value;
if (<roll>5__4 < 0.7f)
{
Repair(<state>5__2);
}
else
{
Remove(<state>5__2);
}
<organs>5__1.ServerSetBodyParts(<state>5__2);
<mgr>5__5 = NetworkSingleton<OrganManager>.Instance;
<mgr>5__5.ServerToggleOrgan(<organs>5__1, (OrganType)0, <state>5__2.leftEye);
<mgr>5__5.ServerToggleOrgan(<organs>5__1, (OrganType)1, <state>5__2.rightEye);
<mgr>5__5.ServerToggleOrgan(<organs>5__1, (OrganType)2, <state>5__2.body);
<mgr>5__5.ServerToggleOrgan(<organs>5__1, (OrganType)3, <state>5__2.mouth);
((ConsumableItem)item).DestroyItem();
return false;
}
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[HarmonyPrefix]
public static bool Prefix(Upgrade __instance, ref IEnumerator __result)
{
string text = ((Object)((Component)__instance).gameObject).name.ToLower();
if (text.Contains("experimental pills"))
{
__result = PillsRoutine(__instance);
return false;
}
return true;
}
[IteratorStateMachine(typeof(<PillsRoutine>d__1))]
private static IEnumerator PillsRoutine(Upgrade item)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <PillsRoutine>d__1(0)
{
item = item
};
}
public static bool GetField(PlayerOrgans obj, string field)
{
FieldInfo field2 = typeof(PlayerOrgans).GetField(field, BindingFlags.Instance | BindingFlags.NonPublic);
return (bool)field2.GetValue(obj);
}
private static PlayerOrganData GetCurrentState(PlayerOrgans organs)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Expected O, but got Unknown
return new PlayerOrganData
{
leftEye = GetField(organs, "_localLeftEye"),
rightEye = GetField(organs, "_localRightEye"),
body = GetField(organs, "_localBody"),
mouth = GetField(organs, "_localMouth")
};
}
private static void Repair(PlayerOrganData d)
{
List<Action> list = new List<Action>();
if (!d.mouth)
{
list.Add(delegate
{
d.mouth = true;
});
}
if (!d.body)
{
list.Add(delegate
{
d.body = true;
});
}
if (!d.leftEye)
{
list.Add(delegate
{
d.leftEye = true;
});
}
if (!d.rightEye)
{
list.Add(delegate
{
d.rightEye = true;
});
}
if (list.Count != 0)
{
list[Random.Range(0, list.Count)]();
}
}
private static void Remove(PlayerOrganData d)
{
List<Action> list = new List<Action>();
bool flag = d.leftEye || d.rightEye;
bool flag2 = d.mouth || d.body;
if (d.mouth)
{
list.Add(delegate
{
d.mouth = false;
});
}
if (d.body)
{
list.Add(delegate
{
d.body = false;
});
}
if (flag)
{
if (d.leftEye && d.rightEye)
{
list.Add(delegate
{
if (Random.value < 0.5f)
{
d.leftEye = false;
}
else
{
d.rightEye = false;
}
});
}
else if (!flag2)
{
if (d.leftEye)
{
list.Add(delegate
{
d.leftEye = false;
});
}
if (d.rightEye)
{
list.Add(delegate
{
d.rightEye = false;
});
}
}
}
if (list.Count != 0)
{
list[Random.Range(0, list.Count)]();
}
}
}
[HarmonyPatch(typeof(GoldenChip), "ApplyChipRoutine")]
public static class GoldenChipPatch
{
[CompilerGenerated]
private sealed class <CursedRoutine>d__3 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public GoldenChip chip;
private GameBase <game>5__1;
private int <uses>5__2;
private bool <cursed>5__3;
private long <loseAmount>5__4;
private MoneyManager <money>5__5;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <CursedRoutine>d__3(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<game>5__1 = null;
<money>5__5 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(1f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
<game>5__1 = chip.Network_targetGame;
if ((Object)(object)<game>5__1 == (Object)null)
{
return false;
}
if (!CursedUses.ContainsKey(chip))
{
CursedUses[chip] = 3;
}
<uses>5__2 = CursedUses[chip];
<uses>5__2--;
CursedUses[chip] = <uses>5__2;
<cursed>5__3 = Random.value <= 0.25f;
if (<cursed>5__3)
{
<loseAmount>5__4 = (long)((float)<game>5__1.MaxBet * 1.5f * NetworkSingleton<UpgradeManager>.Instance.GetUpgradeData(((Component)((Item)chip).NetworkHolder).GetComponent<PlayerProfile>().steamId, (PlayerUpgradeType)2));
<money>5__5 = NetworkSingleton<MoneyManager>.Instance;
if ((Object)(object)<money>5__5 != (Object)null && (Object)(object)((Item)chip).NetworkHolder != (Object)null)
{
<money>5__5.TryChangeBalance(-<loseAmount>5__4, ((Component)((Item)chip).NetworkHolder).GetComponent<PlayerProfile>(), (ChangeType)4);
}
((ConsumableItem)chip).DestroyItem();
<money>5__5 = null;
}
else
{
<game>5__1.ServerSetBet(<game>5__1.MaxBet);
<game>5__1.ApplyGoldenChip(NetworkSingleton<UpgradeManager>.Instance.GetUpgradeData(((Component)((Item)chip).NetworkHolder).GetComponent<PlayerProfile>().steamId, (PlayerUpgradeType)2));
}
((InteractableBase)chip).TooltipMessage = $"<color=#00ffcc>{<uses>5__2} Uses Left</color>";
if (<uses>5__2 <= 0)
{
CursedUses.Remove(chip);
((ConsumableItem)chip).DestroyItem();
}
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private static readonly Dictionary<GoldenChip, int> CursedUses = new Dictionary<GoldenChip, int>();
private const int CursedMaxUses = 3;
[HarmonyPrefix]
public static bool Prefix(GoldenChip __instance, ref IEnumerator __result)
{
string text = ((Object)((Component)__instance).gameObject).name.ToLower();
if (text.Contains("cursed coin"))
{
__result = CursedRoutine(__instance);
return false;
}
return true;
}
[IteratorStateMachine(typeof(<CursedRoutine>d__3))]
private static IEnumerator CursedRoutine(GoldenChip chip)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <CursedRoutine>d__3(0)
{
chip = chip
};
}
}
[HarmonyPatch(typeof(InteractableBase), "get_InteractableName")]
public static class InteractableNamePatch
{
public static bool Prefix(InteractableBase __instance, ref string __result)
{
string text = ((Object)((Component)__instance).gameObject).name.ToLower();
if (text.Contains("cursed coin"))
{
__result = "Cursed Coin";
return false;
}
if (text.Contains("experimental pills"))
{
__result = "Experimental Pills";
return false;
}
if (text.Contains("blind luck"))
{
__result = "Blind Luck";
return false;
}
if (text.Contains("voodoo doll"))
{
__result = "Voodoo Doll";
return false;
}
if (text.Contains("tax fraud"))
{
__result = "Tax Fraud";
return false;
}
if (text.Contains("energy drink"))
{
__result = "Energy Drink";
return false;
}
return true;
}
}
}
namespace Items_Mod_For_Gamble.ModdedItem
{
public sealed class EnergyDrink : Microphone
{
}
[HarmonyPatch(typeof(Item), "OnAwake")]
public static class EnergyDrinkAwakePatch
{
[HarmonyPostfix]
private static void Postfix(Item __instance)
{
Microphone val = (Microphone)(object)((__instance is Microphone) ? __instance : null);
if (!((Object)(object)val == (Object)null))
{
string text = ((Object)((Component)val).gameObject).name.ToLower();
if (text.Contains("energy drink") && ((Item)val).itemActions != null && ((Item)val).itemActions.Count > 0)
{
((Item)val).itemActions.First().actionName = "Consume";
}
}
}
}
internal sealed class BlindLuck : Drink
{
}
[HarmonyPatch(typeof(Item), "OnAwake")]
public static class BlindAwakePatch
{
[HarmonyPostfix]
private static void Postfix(Item __instance)
{
Drink val = (Drink)(object)((__instance is Drink) ? __instance : null);
if ((Object)(object)val == (Object)null)
{
return;
}
string text = ((Object)((Component)val).gameObject).name.ToLower();
if (text.Contains("blind luck"))
{
((InteractableBase)val).TooltipMessage = "Only works if you have both eyes";
if (((Item)val).itemActions != null && ((Item)val).itemActions.Count > 0)
{
((Item)val).itemActions.First().actionName = "Scoop your eyes";
}
AccessTools.Field(typeof(Drink), "_canDrink").SetValue(val, true);
AccessTools.Field(typeof(Drink), "_isBreakable").SetValue(val, false);
}
}
}
public sealed class CursedCoin : GoldenChip
{
}
internal sealed class Experimental_Pills : Upgrade
{
}
[HarmonyPatch(typeof(Item), "OnAwake")]
public static class PillAwakePatch
{
[HarmonyPostfix]
private static void Postfix(Item __instance)
{
Upgrade val = (Upgrade)(object)((__instance is Upgrade) ? __instance : null);
if ((Object)(object)val == (Object)null)
{
return;
}
string text = ((Object)((Component)val).gameObject).name.ToLower();
if (text.Contains("experimental pills"))
{
((InteractableBase)val).TooltipMessage = "Only works if you are missing body parts";
if (((Item)val).itemActions != null && ((Item)val).itemActions.Count > 0)
{
((Item)val).itemActions.First().actionName = "Take a pill";
}
}
}
}
internal sealed class TaxFraud : Taser
{
}
[HarmonyPatch(typeof(Item), "OnAwake")]
public static class TaxAwakePatch
{
[HarmonyPostfix]
private static void Postfix(Item __instance)
{
Taser val = (Taser)(object)((__instance is Taser) ? __instance : null);
if ((Object)(object)val == (Object)null)
{
return;
}
string text = ((Object)((Component)val).gameObject).name.ToLower();
if (text.Contains("tax fraud"))
{
((InteractableBase)val).TooltipMessage = "Lose all cash when audited";
if (((Item)val).itemActions != null && ((Item)val).itemActions.Count > 0)
{
((Item)val).itemActions.First().actionName = "Falsify Taxes";
}
}
}
}
internal sealed class VoodooDoll : Coordinator
{
}
[HarmonyPatch(typeof(Item), "OnAwake")]
public static class DollAwakePatch
{
[HarmonyPostfix]
private static void Postfix(Item __instance)
{
Coordinator val = (Coordinator)(object)((__instance is Coordinator) ? __instance : null);
if ((Object)(object)val == (Object)null)
{
return;
}
string text = ((Object)((Component)val).gameObject).name.ToLower();
if (text.Contains("voodoo doll"))
{
((InteractableBase)val).TooltipMessage = "Only works if you have body parts to lose";
if (((Item)val).itemActions != null && ((Item)val).itemActions.Count > 0)
{
((Item)val).itemActions.First().actionName = "Poke";
((Item)val).itemActions.Last().actionName = "Throw";
((Item)val).itemActions.RemoveAt(1);
}
AccessTools.Field(typeof(Coordinator), "_isBreakable").SetValue(val, false);
}
}
}
}
