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 System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Dawn;
using Dawn.Utils;
using GameNetcodeStuff;
using HarmonyLib;
using ImprovedLethalThings.Items;
using ImprovedLethalThings.NetcodePatcher;
using ImprovedLethalThings.Networking;
using ImprovedLethalThings.Patches;
using ImprovedLethalThings.Util;
using ImprovedLethalThings.patches;
using LethalCompanyInputUtils.Api;
using LethalCompanyInputUtils.BindingPathEnums;
using LethalThings;
using LethalThings.MonoBehaviours;
using Microsoft.CodeAnalysis;
using On;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ImprovedLethalThings")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Mod for Lethal Company")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("ImprovedLethalThings")]
[assembly: AssemblyTitle("ImprovedLethalThings")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace ImprovedLethalThings
{
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("HQ_Team.ImprovedLethalThings", "ImprovedLethalThings", "1.0.2")]
public class ImprovedLethalThings : BaseUnityPlugin
{
[CompilerGenerated]
private static class <>O
{
public static Action<Harmony> <0>__TryApply;
public static hook_Awake <1>__StartOfRound_Awake;
}
public static ImprovedLethalThings instance;
public ConfigFile config;
public static ManualLogSource Log;
public void Awake()
{
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: Expected O, but got Unknown
//IL_04ab: Unknown result type (might be due to invalid IL or missing references)
//IL_04b0: Unknown result type (might be due to invalid IL or missing references)
//IL_04b6: Expected O, but got Unknown
Type[] types = Assembly.GetExecutingAssembly().GetTypes();
Type[] array = types;
foreach (Type type in array)
{
MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
MethodInfo[] array2 = methods;
foreach (MethodInfo methodInfo in array2)
{
object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
if (customAttributes.Length != 0)
{
methodInfo.Invoke(null, null);
}
}
}
instance = this;
Log = ((BaseUnityPlugin)this).Logger;
Harmony val = new Harmony("HQ_Team.ImprovedLethalThings");
Action<Harmony>[] array3 = new Action<Harmony>[1] { RocketLauncherReflection.TryApply };
Action<Harmony>[] array4 = array3;
foreach (Action<Harmony> action in array4)
{
try
{
action(val);
}
catch
{
}
}
val.PatchAll(typeof(HackingToolPatch));
val.PatchAll(typeof(HandheldRadarPatch));
val.PatchAll(typeof(PingerPatch));
val.PatchAll(typeof(RocketLauncherReloadInput));
val.PatchAll(typeof(RocketLauncherReloadTip));
val.PatchAll(typeof(HackingToolTipUtil));
val.PatchAll(typeof(MissilePatch));
val.PatchAll(typeof(FlareControllerPatch));
((BaseUnityPlugin)this).Logger.LogInfo((object)"LethalThings Improved!");
ConfigEntry<bool> val2 = ((BaseUnityPlugin)this).Config.Bind<bool>("Hacking Tool", "EnableEnhancedHackGame", true, "Enable the custom hacking minigame from EnhancedLethalThings.");
HackingToolPatch.ToggleEnhancedHackGame = val2.Value;
ConfigEntry<float> val3 = ((BaseUnityPlugin)this).Config.Bind<float>("Hacking Tool", "ConnectionTime", HackingToolPatch.ConnectionTime, "How long it will take to connect to a target, in seconds.");
HackingToolPatch.ConnectionTime = val3.Value;
ConfigEntry<float> val4 = ((BaseUnityPlugin)this).Config.Bind<float>("Hacking Tool", "Battery", HackingToolPatch.HackBattery, "Battery size.");
HackingToolPatch.HackBattery = val4.Value;
ConfigEntry<int> val5 = ((BaseUnityPlugin)this).Config.Bind<int>("Hacking Tool", "AnswerNumber", HackingToolPatch.HackCount, "The length of hacking tool answer. Maximum of 9.");
HackingToolPatch.HackCount = Math.Max(1, val5.Value);
ConfigEntry<float> val6 = ((BaseUnityPlugin)this).Config.Bind<float>("Hacking Tool", "HackDistance", HackingToolPatch.MaxHackDistance, "Hacking distance range");
HackingToolPatch.MaxHackDistance = val6.Value;
ConfigEntry<float> val7 = ((BaseUnityPlugin)this).Config.Bind<float>("Hacking Tool", "HackSpreadDistance", HackingToolPatch.HackSpreadDistance, "Distance in which the hack can be spread to other hackable objects.");
HackingToolPatch.HackSpreadDistance = val7.Value;
ConfigEntry<float> val8 = ((BaseUnityPlugin)this).Config.Bind<float>("Hacking Tool", "DoorCooldown", HackingToolPatch.DoorCooldownTime, "Cooldown duration for hacked doors before they can be hacked again, in seconds.");
HackingToolPatch.DoorCooldownTime = val8.Value;
ConfigEntry<float> val9 = ((BaseUnityPlugin)this).Config.Bind<float>("Hacking Tool", "TurretDisableTime", HackingToolPatch.TurretDisableTime, "How long turrets stay disabled when hacked, in seconds.");
HackingToolPatch.TurretDisableTime = val9.Value;
ConfigEntry<float> val10 = ((BaseUnityPlugin)this).Config.Bind<float>("Hacking Tool", "SpikeDisableTime", 10f, "How long spikes stay disabled when hacked, in seconds.");
HackingToolPatch.SpikeDisableTime = val10.Value;
ConfigEntry<bool> val11 = ((BaseUnityPlugin)this).Config.Bind<bool>("Hacking Tool", "LandmineExplodeOnHack", HackingToolPatch.LandmineExplodeOnHack, "If true, hacked landmines will explode; if false, they will be disabled temporarily instead.");
HackingToolPatch.LandmineExplodeOnHack = val11.Value;
ConfigEntry<float> val12 = ((BaseUnityPlugin)this).Config.Bind<float>("Hacking Tool", "LandmineDisableTime", HackingToolPatch.LandmineDisableTime, "How long hacked landmines stay disabled when not exploded, in seconds.");
HackingToolPatch.LandmineDisableTime = val12.Value;
ConfigEntry<float> val13 = ((BaseUnityPlugin)this).Config.Bind<float>("Handheld Radar", "Battery", HandheldRadarPatch.RadarCapacity, "Battery size.");
HandheldRadarPatch.RadarCapacity = val13.Value;
ConfigEntry<int> val14 = ((BaseUnityPlugin)this).Config.Bind<int>("Pinger", "MaxUses", PingerPatch.MaxUses, "How many pings before the tool is exhausted.");
PingerPatch.MaxUses = val14.Value;
ConfigEntry<float> val15 = ((BaseUnityPlugin)this).Config.Bind<float>("Pinger", "PingDuration", PingerPatch.PingDuration, "How long the ping marker lasts before fading.");
PingerPatch.PingDuration = val15.Value;
ConfigEntry<float> val16 = ((BaseUnityPlugin)this).Config.Bind<float>("Pinger", "PingRange", PingerPatch.PingRange, "Maximum detection range of the Pinger scan node.");
PingerPatch.PingRange = val16.Value;
ConfigEntry<int> val17 = ((BaseUnityPlugin)this).Config.Bind<int>("Rocket Launcher", "Missile Ammo Cost", 100, "Price of the Missile item in the store.");
MissileRegistration.RegisterMissileItem(this, val17.Value);
_ = HackToolInputBindings._instance;
HackToolInputBindings._instance.PowerToggle.performed += OnPowerToggle;
HackToolInputBindings._instance.ModeToggle.performed += OnModeToggle;
object obj2 = <>O.<1>__StartOfRound_Awake;
if (obj2 == null)
{
hook_Awake val18 = StartOfRound_Awake;
<>O.<1>__StartOfRound_Awake = val18;
obj2 = (object)val18;
}
StartOfRound.Awake += (hook_Awake)obj2;
}
private static void StartOfRound_Awake(orig_Awake orig, StartOfRound self)
{
NetworkManager singleton = NetworkManager.Singleton;
object obj;
if (singleton == null)
{
obj = null;
}
else
{
NetworkConfig networkConfig = singleton.NetworkConfig;
if (networkConfig == null)
{
obj = null;
}
else
{
NetworkPrefabs prefabs = networkConfig.Prefabs;
obj = ((prefabs != null) ? prefabs.Prefabs : null);
}
}
IReadOnlyList<NetworkPrefab> readOnlyList = (IReadOnlyList<NetworkPrefab>)obj;
if (readOnlyList != null)
{
foreach (NetworkPrefab item in readOnlyList)
{
if (!((Object)(object)item?.Prefab == (Object)null) && (Object)(object)item.Prefab.GetComponent<RocketLauncher>() != (Object)null && (Object)(object)item.Prefab.GetComponent<RocketLauncherReload>() == (Object)null)
{
item.Prefab.AddComponent<RocketLauncherReload>();
}
}
}
orig.Invoke(self);
}
private void OnPowerToggle(CallbackContext ctx)
{
GrabbableObject obj = GameNetworkManager.Instance?.localPlayerController?.currentlyHeldObjectServer;
HackingTool val = (HackingTool)(object)((obj is HackingTool) ? obj : null);
if ((Object)(object)val != (Object)null)
{
HackingToolPatch.TogglePower(val);
}
}
private void OnModeToggle(CallbackContext ctx)
{
GrabbableObject obj = GameNetworkManager.Instance?.localPlayerController?.currentlyHeldObjectServer;
HackingTool val = (HackingTool)(object)((obj is HackingTool) ? obj : null);
if ((Object)(object)val != (Object)null)
{
HackingToolPatch.ToggleHackMode(val);
}
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "HQ_Team.ImprovedLethalThings";
public const string PLUGIN_NAME = "ImprovedLethalThings";
public const string PLUGIN_VERSION = "1.0.2";
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "ImprovedLethalThings";
public const string PLUGIN_NAME = "ImprovedLethalThings";
public const string PLUGIN_VERSION = "1.0.0";
}
}
namespace ImprovedLethalThings.Util
{
[HarmonyPatch]
public static class HackingToolTipUtil
{
public static void UpdateHackingToolTips()
{
HUDManager instance = HUDManager.Instance;
if (!((Object)(object)instance == (Object)null) && instance.controlTipLines != null)
{
for (int i = 0; i < instance.controlTipLines.Length; i++)
{
((TMP_Text)instance.controlTipLines[i]).text = "";
}
string text = ((Keyboard.current != null) ? ((InputControl)Keyboard.current.gKey).displayName : "G");
string bindingDisplayString = InputActionRebindingExtensions.GetBindingDisplayString(HackToolInputBindings._instance.PowerToggle, (DisplayStringOptions)0, (string)null);
string bindingDisplayString2 = InputActionRebindingExtensions.GetBindingDisplayString(HackToolInputBindings._instance.ModeToggle, (DisplayStringOptions)0, (string)null);
string[] array = new string[4]
{
"Drop Hacking Tool : [" + text + "]",
"Turn on : [" + bindingDisplayString + "]",
"Switch modes : [" + bindingDisplayString2 + "]",
"Select target : [LMB]"
};
int num = Mathf.Min(array.Length, instance.controlTipLines.Length);
for (int j = 0; j < num; j++)
{
((TMP_Text)instance.controlTipLines[j]).text = array[j];
}
}
}
public static void ClearHackingToolTips()
{
HUDManager instance = HUDManager.Instance;
if (!((Object)(object)instance == (Object)null) && instance.controlTipLines != null)
{
for (int i = 0; i < instance.controlTipLines.Length; i++)
{
((TMP_Text)instance.controlTipLines[i]).text = "";
}
}
}
[HarmonyPatch(typeof(HackingTool), "EquipItem")]
[HarmonyPostfix]
private static void EquipItem_Postfix(HackingTool __instance)
{
if (!((GrabbableObject)__instance).isHeld)
{
return;
}
if (!((Object)(object)__instance == (Object)null))
{
PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
if (!((Object)(object)localPlayerController == (Object)null) && !((Object)(object)localPlayerController.currentlyHeldObjectServer != (Object)(object)__instance) && ((NetworkBehaviour)__instance).IsOwner)
{
UpdateHackingToolTips();
}
}
}
[HarmonyPatch(typeof(GrabbableObject), "PocketItem")]
[HarmonyPostfix]
private static void PocketItem_Postfix(GrabbableObject __instance)
{
HackingTool val = (HackingTool)(object)((__instance is HackingTool) ? __instance : null);
if ((Object)(object)val == (Object)null)
{
return;
}
if (!((GrabbableObject)val).isHeld)
{
ClearHackingToolTips();
return;
}
PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
if (!((Object)(object)localPlayerController == (Object)null))
{
if ((Object)(object)localPlayerController.currentlyHeldObjectServer != (Object)(object)val)
{
ClearHackingToolTips();
}
else if (((NetworkBehaviour)val).IsOwner)
{
UpdateHackingToolTips();
}
}
}
}
public class HackToolInputBindings : LcInputActions
{
public static readonly HackToolInputBindings _instance = new HackToolInputBindings();
public InputAction PowerToggle => ((LcInputActions)this).Asset["hacking_tool_power_toggle"];
public InputAction ModeToggle => ((LcInputActions)this).Asset["hacking_tool_mode_toggle"];
public override void CreateInputActions(in InputActionMapBuilder builder)
{
builder.NewActionBinding().WithActionId("hacking_tool_power_toggle").WithActionType((InputActionType)1)
.WithKeyboardControl((KeyboardControl)37)
.WithBindingName("Hacking Tool Power Toggle")
.Finish();
builder.NewActionBinding().WithActionId("hacking_tool_mode_toggle").WithActionType((InputActionType)1)
.WithKeyboardControl((KeyboardControl)25)
.WithBindingName("Hacking Tool Mode Toggle")
.Finish();
}
}
internal static class RocketLauncherReflection
{
private static readonly FieldInfo currentAmmoField = typeof(RocketLauncher).GetField("currentAmmo", BindingFlags.Instance | BindingFlags.NonPublic);
public static void TryApply(Harmony h)
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Expected O, but got Unknown
h.Patch((MethodBase)AccessTools.Method(typeof(RocketLauncher), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(RocketLauncherReflection).GetMethod("ValidateAmmoField")), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
}
private static void ValidateAmmoField(RocketLauncher __instance)
{
if (!(currentAmmoField == null))
{
currentAmmoField.GetValue(__instance);
}
}
}
}
namespace ImprovedLethalThings.Patches
{
public class HackingToolPatch
{
[CompilerGenerated]
private sealed class <ReEnableLandmineAfterDelay>d__18 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public Landmine lm;
public float delay;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <ReEnableLandmineAfterDelay>d__18(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(delay);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if ((Object)(object)lm == (Object)null || lm.hasExploded)
{
return false;
}
lm.ToggleMine(true);
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();
}
}
[CompilerGenerated]
private sealed class <ReEnableSpikesAfterDelay>d__17 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public SpikeRoofTrap spikes;
public float delay;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <ReEnableSpikesAfterDelay>d__17(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(delay);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if ((Object)(object)spikes == (Object)null)
{
return false;
}
if (NetworkManager.Singleton.IsServer || NetworkManager.Singleton.IsHost)
{
spikes.ToggleSpikesEnabled(true);
}
else
{
spikes.ToggleSpikesServerRpc(true);
}
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();
}
}
[CompilerGenerated]
private sealed class <ReEnableTurretAfterDelay>d__16 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public Turret turret;
public float delay;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <ReEnableTurretAfterDelay>d__16(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(delay);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if ((Object)(object)turret == (Object)null)
{
return false;
}
if (((NetworkBehaviour)turret).IsHost)
{
turret.ToggleTurretClientRpc(true);
}
else
{
turret.ToggleTurretServerRpc(true);
}
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();
}
}
[CompilerGenerated]
private sealed class <ResetCooldownAfterDelay>d__15 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public TerminalAccessibleObject obj;
public float delay;
private Traverse <t>5__1;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <ResetCooldownAfterDelay>d__15(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<t>5__1 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(delay);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if ((Object)(object)obj != (Object)null)
{
<t>5__1 = Traverse.Create((object)obj);
<t>5__1.Field("inCooldown").SetValue((object)false);
<t>5__1.Field("currentCooldownTimer").SetValue((object)0f);
<t>5__1 = 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();
}
}
public static int HackCount = 8;
public static float MaxHackDistance = 15f;
public static float HackSpreadDistance = 20f;
public static float ConnectionTime = 8f;
public static float HackBattery = 200f;
public static float TurretDisableTime = 15f;
public static float DoorCooldownTime = 5f;
public static float SpikeDisableTime = 10f;
public static bool ToggleEnhancedHackGame = true;
public static bool LandmineExplodeOnHack = true;
public static float LandmineDisableTime = 10f;
private static readonly FieldRef<TerminalAccessibleObject, bool> inCooldownRef = AccessTools.FieldRefAccess<TerminalAccessibleObject, bool>("inCooldown");
private static readonly FieldRef<TerminalAccessibleObject, bool> isPoweredOnRef = AccessTools.FieldRefAccess<TerminalAccessibleObject, bool>("isPoweredOn");
private static float lastToggleTime = 0f;
private static bool CheckNotAccessable(TerminalAccessibleObject obj)
{
return inCooldownRef.Invoke(obj) || !isPoweredOnRef.Invoke(obj);
}
private static void StopTurret(Turret turret)
{
if (!((Object)(object)turret == (Object)null))
{
if (((NetworkBehaviour)turret).IsHost)
{
turret.ToggleTurretClientRpc(false);
}
else
{
turret.ToggleTurretServerRpc(false);
}
((MonoBehaviour)turret).StartCoroutine(ReEnableTurretAfterDelay(turret, TurretDisableTime));
}
}
[IteratorStateMachine(typeof(<ResetCooldownAfterDelay>d__15))]
private static IEnumerator ResetCooldownAfterDelay(TerminalAccessibleObject obj, float delay)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <ResetCooldownAfterDelay>d__15(0)
{
obj = obj,
delay = delay
};
}
[IteratorStateMachine(typeof(<ReEnableTurretAfterDelay>d__16))]
private static IEnumerator ReEnableTurretAfterDelay(Turret turret, float delay)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <ReEnableTurretAfterDelay>d__16(0)
{
turret = turret,
delay = delay
};
}
[IteratorStateMachine(typeof(<ReEnableSpikesAfterDelay>d__17))]
private static IEnumerator ReEnableSpikesAfterDelay(SpikeRoofTrap spikes, float delay)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <ReEnableSpikesAfterDelay>d__17(0)
{
spikes = spikes,
delay = delay
};
}
[IteratorStateMachine(typeof(<ReEnableLandmineAfterDelay>d__18))]
private static IEnumerator ReEnableLandmineAfterDelay(Landmine lm, float delay)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <ReEnableLandmineAfterDelay>d__18(0)
{
lm = lm,
delay = delay
};
}
private static void ResetNearbyTerminalObjects(Vector3 origin, float delay)
{
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
TerminalAccessibleObject[] array = Object.FindObjectsOfType<TerminalAccessibleObject>();
foreach (TerminalAccessibleObject val in array)
{
if (Vector3.Distance(((Component)val).transform.position, origin) <= MaxHackDistance)
{
((MonoBehaviour)val).StartCoroutine(ResetCooldownAfterDelay(val, delay));
}
}
}
[HarmonyPatch(typeof(HackingTool), "SwitchHackState")]
[HarmonyPrefix]
public static void SwitchHackState_Prefix(HackingTool __instance, ref HackState state, ref TerminalAccessibleObject ___selectedTarget)
{
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Invalid comparison between Unknown and I4
bool isTurretMode = IsTurretMode(__instance.hackUpdateTime);
if (((NetworkBehaviour)__instance).IsOwner && (int)state == 5 && (Object)(object)___selectedTarget != (Object)null && (int)__instance.hackState.Value != (int)state)
{
HackingRangeServerRpc(((Component)___selectedTarget).transform.position, isTurretMode);
}
}
[ServerRpc(RequireOwnership = false)]
private static void HackingRangeServerRpc(Vector3 position, bool isTurretMode)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
HackingRangeClientRpc(position, isTurretMode);
}
[ClientRpc]
private static void HackingRangeClientRpc(Vector3 position, bool isTurretMode)
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_03ec: Unknown result type (might be due to invalid IL or missing references)
//IL_0406: Unknown result type (might be due to invalid IL or missing references)
//IL_0167: Unknown result type (might be due to invalid IL or missing references)
//IL_0181: Unknown result type (might be due to invalid IL or missing references)
//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
//IL_0262: Unknown result type (might be due to invalid IL or missing references)
//IL_0275: Unknown result type (might be due to invalid IL or missing references)
//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
//IL_0317: Unknown result type (might be due to invalid IL or missing references)
TerminalAccessibleObject[] array = Object.FindObjectsOfType<TerminalAccessibleObject>();
TerminalAccessibleObject[] array2 = array;
foreach (TerminalAccessibleObject val in array2)
{
if ((Object)(object)val == (Object)null || Vector3.Distance(((Component)val).transform.position, position) >= MaxHackDistance)
{
continue;
}
bool flag = (Object)(object)((Component)val).GetComponentInParent<Turret>() != (Object)null;
bool flag2 = (Object)(object)((Component)val).GetComponentInParent<Landmine>() != (Object)null;
Transform val2 = (((Object)(object)((Component)val).transform.parent != (Object)null && (Object)(object)((Component)val).transform.parent.parent != (Object)null) ? ((Component)val).transform.parent.parent : null);
bool flag3 = (Object)(object)val2 != (Object)null && (Object)(object)((Component)val2).GetComponentInChildren<SpikeRoofTrap>() != (Object)null;
if (isTurretMode)
{
if (!flag && !flag2 && !flag3)
{
continue;
}
Traverse val3 = Traverse.Create((object)val);
val3.Field("inCooldown").SetValue((object)true);
val3.Field("currentCooldownTimer").SetValue((object)TurretDisableTime);
object value = val3.Field("mapRadarText").GetValue();
TextMeshProUGUI val4 = (TextMeshProUGUI)((value is TextMeshProUGUI) ? value : null);
object value2 = val3.Field("mapRadarBox").GetValue();
Image val5 = (Image)((value2 is Image) ? value2 : null);
if (Object.op_Implicit((Object)(object)val4))
{
((Graphic)val4).color = Color.red;
}
if (Object.op_Implicit((Object)(object)val5))
{
((Graphic)val5).color = Color.red;
}
Turret componentInParent = ((Component)val).GetComponentInParent<Turret>();
if ((Object)(object)componentInParent != (Object)null)
{
StopTurret(componentInParent);
ResetNearbyTerminalObjects(((Component)val).transform.position, TurretDisableTime);
}
Landmine componentInParent2 = ((Component)val).GetComponentInParent<Landmine>();
if ((Object)(object)componentInParent2 != (Object)null && !componentInParent2.hasExploded)
{
if (LandmineExplodeOnHack)
{
if (((NetworkBehaviour)componentInParent2).IsHost)
{
componentInParent2.ExplodeMineClientRpc();
}
else
{
componentInParent2.ExplodeMineServerRpc();
}
}
else if (NetworkManager.Singleton.IsServer || NetworkManager.Singleton.IsHost)
{
componentInParent2.ToggleMine(false);
((MonoBehaviour)componentInParent2).StartCoroutine(ReEnableLandmineAfterDelay(componentInParent2, LandmineDisableTime));
}
else
{
DisableLandmineServerRpc(((Component)componentInParent2).transform.position);
}
ResetNearbyTerminalObjects(((Component)val).transform.position, LandmineDisableTime);
}
SpikeRoofTrap val6 = (((Object)(object)val2 != (Object)null) ? ((Component)val2).GetComponentInChildren<SpikeRoofTrap>() : null);
if ((Object)(object)val6 != (Object)null)
{
if (NetworkManager.Singleton.IsServer || NetworkManager.Singleton.IsHost)
{
val6.ToggleSpikesEnabled(false);
((MonoBehaviour)val6).StartCoroutine(ReEnableSpikesAfterDelay(val6, SpikeDisableTime));
}
else
{
DisableSpikesServerRpc(((Component)val6).transform.position);
}
((MonoBehaviour)val).StartCoroutine(ResetCooldownAfterDelay(val, SpikeDisableTime));
ResetNearbyTerminalObjects(((Component)val).transform.position, SpikeDisableTime);
}
}
else if (!(flag || flag2 || flag3))
{
Traverse val7 = Traverse.Create((object)val);
val7.Field("inCooldown").SetValue((object)false);
val7.Method("CallFunctionFromTerminal", Array.Empty<object>()).GetValue();
val7.Field("inCooldown").SetValue((object)true);
val7.Field("currentCooldownTimer").SetValue((object)DoorCooldownTime);
object value3 = val7.Field("mapRadarText").GetValue();
TextMeshProUGUI val8 = (TextMeshProUGUI)((value3 is TextMeshProUGUI) ? value3 : null);
object value4 = val7.Field("mapRadarBox").GetValue();
Image val9 = (Image)((value4 is Image) ? value4 : null);
if (Object.op_Implicit((Object)(object)val8))
{
((Graphic)val8).color = Color.red;
}
if (Object.op_Implicit((Object)(object)val9))
{
((Graphic)val9).color = Color.red;
}
((MonoBehaviour)val).StartCoroutine(ResetCooldownAfterDelay(val, DoorCooldownTime));
}
}
}
[ServerRpc(RequireOwnership = false)]
private static void DisableSpikesServerRpc(Vector3 position)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
DisableSpikesClientRpc(position);
}
[ClientRpc]
private static void DisableSpikesClientRpc(Vector3 position)
{
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: 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)
SpikeRoofTrap[] array = Object.FindObjectsOfType<SpikeRoofTrap>();
foreach (SpikeRoofTrap val in array)
{
if (!(Vector3.Distance(((Component)val).transform.position, position) > MaxHackDistance))
{
val.ToggleSpikesEnabled(false);
((MonoBehaviour)val).StartCoroutine(ReEnableSpikesAfterDelay(val, SpikeDisableTime));
ResetNearbyTerminalObjects(position, SpikeDisableTime);
}
}
}
[ServerRpc(RequireOwnership = false)]
private static void DisableLandmineServerRpc(Vector3 position)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
DisableLandmineClientRpc(position);
}
[ClientRpc]
private static void DisableLandmineClientRpc(Vector3 position)
{
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
Landmine[] array = Object.FindObjectsOfType<Landmine>();
foreach (Landmine val in array)
{
if (!(Vector3.Distance(((Component)val).transform.position, position) > MaxHackDistance) && !val.hasExploded)
{
val.ToggleMine(false);
((MonoBehaviour)val).StartCoroutine(ReEnableLandmineAfterDelay(val, LandmineDisableTime));
ResetNearbyTerminalObjects(position, LandmineDisableTime);
}
}
}
[HarmonyPatch(typeof(HackingTool), "SwitchHackState")]
[HarmonyPostfix]
public static void SwitchHackState_Postfix(HackingTool __instance, ref HackState state, ref TerminalAccessibleObject ___selectedTarget)
{
if ((int)state == 1)
{
if (IsDoorMode(__instance.hackUpdateTime))
{
((TMP_Text)__instance.targetString).text = "No door";
}
else
{
((TMP_Text)__instance.targetString).text = "No turret/mine/spikes";
}
}
if ((int)state == 2)
{
__instance.connectionTime = ConnectionTime;
}
__instance.maxHackDistance = MaxHackDistance;
__instance.hackCount = HackCount;
}
private static bool IsTurretMode(float f)
{
return 10000f <= f && f < 20000f;
}
private static bool IsDoorMode(float f)
{
return 20000f <= f;
}
private static float RealUpdateTime(float f)
{
return (f > 20000f) ? (f - 20000f) : ((f > 10000f) ? (f - 10000f) : f);
}
public static void TogglePower(HackingTool tool)
{
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Invalid comparison between Unknown and I4
if (!((NetworkBehaviour)tool).IsOwner || Time.time - lastToggleTime < 0.25f)
{
return;
}
lastToggleTime = Time.time;
HackState value = tool.hackState.Value;
if ((int)value == 0)
{
tool.SwitchHackState((HackState)1);
tool.PlaySoundByID("turnOn");
if ((Object)(object)tool.backLight != (Object)null)
{
((Behaviour)tool.backLight).enabled = true;
}
return;
}
tool.SwitchHackState((HackState)0);
tool.PlaySoundByID("turnOff");
if ((Object)(object)tool.backLight != (Object)null)
{
((Behaviour)tool.backLight).enabled = false;
}
typeof(HackingTool).GetField("selectedTarget", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(tool, null);
}
[HarmonyPatch(typeof(HackingTool), "ItemInteractLeftRight")]
[HarmonyPrefix]
private static bool DisableOriginalPowerInput(HackingTool __instance, bool right)
{
if (!((NetworkBehaviour)__instance).IsOwner)
{
return true;
}
if (!right)
{
return false;
}
return true;
}
public static void ToggleHackMode(HackingTool instance)
{
if (!((Object)(object)instance == (Object)null) && instance.turnedOn)
{
instance.hackUpdateTime = (IsDoorMode(instance.hackUpdateTime) ? 10000f : 20000f);
}
}
[HarmonyPatch(typeof(HackingTool), "Update")]
[HarmonyPrefix]
private static void Update_Prefix(HackingTool __instance, ref TerminalAccessibleObject ___selectedTarget, ref float ___hackUpdateTimer)
{
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Invalid comparison between Unknown and I4
//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
if (__instance.hackUpdateTime < 10000f)
{
__instance.hackUpdateTime = 10000f;
}
else if (__instance.hackUpdateTime >= 20000f)
{
__instance.hackUpdateTime = 20000f;
}
if ((int)__instance.hackState.Value != 1)
{
return;
}
bool flag = IsDoorMode(__instance.hackUpdateTime);
___hackUpdateTimer = 0f;
__instance.hackUpdateTime += Time.deltaTime;
if (RealUpdateTime(__instance.hackUpdateTime) > 2f)
{
__instance.hackUpdateTime = (flag ? 20000f : 10000f);
return;
}
TerminalAccessibleObject val = null;
float num = __instance.maxHackDistance;
int num2 = 0;
TerminalAccessibleObject[] array = Object.FindObjectsOfType<TerminalAccessibleObject>();
foreach (TerminalAccessibleObject val2 in array)
{
if ((Object)(object)val2 == (Object)null || CheckNotAccessable(val2))
{
continue;
}
Landmine componentInParent = ((Component)val2).GetComponentInParent<Landmine>();
if ((Object)(object)componentInParent != (Object)null && componentInParent.hasExploded)
{
continue;
}
bool flag2 = (Object)(object)((Component)val2).GetComponentInParent<Turret>() != (Object)null;
bool flag3 = (Object)(object)((Component)val2).GetComponentInParent<Landmine>() != (Object)null;
Transform val3 = (((Object)(object)((Component)val2).transform.parent != (Object)null && (Object)(object)((Component)val2).transform.parent.parent != (Object)null) ? ((Component)val2).transform.parent.parent : null);
bool flag4 = (Object)(object)val3 != (Object)null && (Object)(object)((Component)val3).GetComponentInChildren<SpikeRoofTrap>() != (Object)null;
bool flag5 = flag2 || flag3 || flag4;
if (!(flag && flag5) && (flag || flag5))
{
float num3 = Vector3.Distance(((Component)val2).transform.position, ((Component)__instance).transform.position);
if (num3 < __instance.maxHackDistance)
{
num2++;
}
if (num3 < num)
{
num = num3;
val = val2;
}
}
}
if ((Object)(object)val != (Object)null)
{
___selectedTarget = val;
if (flag)
{
((TMP_Text)__instance.targetString).text = "Door\n" + val.objectCode;
return;
}
string text = ((num2 <= 1) ? "" : $"+{num2}");
string text2 = (((Object)(object)((Component)val).GetComponentInParent<Turret>() != (Object)null) ? "Turret" : (((Object)(object)((Component)val).GetComponentInParent<Landmine>() != (Object)null) ? "Mine" : "Spikes"));
((TMP_Text)__instance.targetString).text = text2 + "\n" + val.objectCode + "\n" + text;
}
else
{
___selectedTarget = null;
((TMP_Text)__instance.targetString).text = (flag ? "No door" : "No turret/mine/spikes");
}
}
[HarmonyPatch(typeof(HackingTool), "GenerateHack")]
[HarmonyPrefix]
private static bool GenerateHack_Prefix(ref HackingTool __instance, ref string ___answerString)
{
if (!ToggleEnhancedHackGame)
{
return true;
}
if (___answerString.Length == 0)
{
int num = Random.Range((int)Math.Pow(10.0, HackCount - 1), (int)Math.Pow(10.0, HackCount) - 1);
((TMP_Text)__instance.hackString).text = num.ToString();
__instance.currentHackAnswer = (int)char.GetNumericValue(((TMP_Text)__instance.hackString).text[0]);
}
else
{
__instance.currentHackAnswer = (int)char.GetNumericValue(((TMP_Text)__instance.hackString).text[__instance.currentHack]);
}
return false;
}
[HarmonyPatch(typeof(HackingTool), "ItemActivate")]
[HarmonyPrefix]
private static void ItemActivate_Prefix(ref HackingTool __instance)
{
((GrabbableObject)__instance).itemProperties.batteryUsage = HackBattery;
}
[HarmonyPatch(typeof(HackingTool), "SwitchHackState")]
[HarmonyPostfix]
private static void SwitchHackState_HackingUI(HackingTool __instance, HackState state)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Invalid comparison between Unknown and I4
if ((int)state == 3)
{
__instance.hackCount = HackCount;
__instance.GenerateHack();
((TMP_Text)__instance.progressString).text = string.Join("", Enumerable.Repeat("_", __instance.hackCount));
}
}
[HarmonyPatch(typeof(HackingTool), "DiscardItem")]
[HarmonyPrefix]
private static bool DiscardItem_Prefix(HackingTool __instance)
{
if (!((NetworkBehaviour)__instance).IsOwner)
{
Type typeFromHandle = typeof(HackingTool);
typeFromHandle.GetField("selectedTarget", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(__instance, null);
typeFromHandle.GetField("currentHack", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(__instance, 1);
typeFromHandle.GetField("currentHackAnswer", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(__instance, 0);
typeFromHandle.GetField("answerString", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(__instance, "");
if ((Object)(object)__instance.backLight != (Object)null)
{
((Behaviour)__instance.backLight).enabled = false;
}
return false;
}
return true;
}
[HarmonyPatch(typeof(HackingTool), "PlaySoundByID")]
[HarmonyPrefix]
private static bool PreventNonOwnerSounds(HackingTool __instance)
{
return ((NetworkBehaviour)__instance).IsOwner;
}
}
public class HandheldRadarPatch
{
public static float RadarCapacity = 200f;
[HarmonyPatch(typeof(HandheldRadar), "Start")]
[HarmonyPostfix]
private static void Start_Postfix(HandheldRadar __instance)
{
((GrabbableObject)__instance).itemProperties.requiresBattery = true;
((GrabbableObject)__instance).itemProperties.batteryUsage = RadarCapacity;
}
}
[HarmonyPatch(typeof(Missile))]
public static class MissilePatch
{
private static float checkRadius = 0.6f;
private static int layerMask = LayerMask.GetMask(new string[1] { "Enemies" });
[HarmonyPostfix]
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
private static void FixedUpdate_Postfix(Missile __instance)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
Collider[] array = Physics.OverlapSphere(((Component)__instance).transform.position, checkRadius, layerMask);
Collider[] array2 = array;
foreach (Collider val in array2)
{
if ((Object)(object)((Component)val).GetComponent<EnemyAICollisionDetect>() != (Object)null || ((Component)val).CompareTag("Enemy"))
{
if (((NetworkBehaviour)__instance).IsHost)
{
__instance.Boom();
__instance.BoomClientRpc();
}
else
{
__instance.BoomServerRpc();
}
break;
}
}
}
[HarmonyPrefix]
[HarmonyPatch("CreateExplosion")]
private static bool CreateExplosion_Prefix(Missile __instance)
{
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
PlayerControllerB val = null;
PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
foreach (PlayerControllerB val2 in allPlayerScripts)
{
if (((NetworkBehaviour)val2).OwnerClientId == ((NetworkBehaviour)__instance).OwnerClientId)
{
val = val2;
break;
}
}
float num = (float)__instance.damage * 2f;
float num2 = __instance.maxDistance * 1.25f;
float num3 = Mathf.Max(__instance.minDistance, 1.5f);
Utilities.CreateExplosion(((Component)__instance).transform.position, true, (int)num, num3, num2, 10, (CauseOfDeath)3, val);
return false;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(Debug), "Log", new Type[] { typeof(object) })]
private static bool PreventMissileSpam(object message)
{
if (message is string text && text.StartsWith("Time alive:"))
{
return false;
}
return true;
}
}
public static class PingerBatteryControl
{
public static bool AllowDrain;
}
[HarmonyPatch(typeof(Pinger))]
public static class PingerPatch
{
[HarmonyPatch(typeof(Pinger))]
public static class PingerScreenStripPatch
{
[HarmonyPostfix]
[HarmonyPatch("Awake")]
private static void Awake_Postfix(Pinger __instance)
{
if ((Object)(object)__instance == (Object)null)
{
return;
}
MeshRenderer mainObjectRenderer = ((GrabbableObject)__instance).mainObjectRenderer;
if (!((Object)(object)mainObjectRenderer == (Object)null))
{
Material[] materials = ((Renderer)mainObjectRenderer).materials;
if (materials != null && materials.Length != 0 && materials.Length > 1)
{
Material[] materials2 = (Material[])(object)new Material[1] { materials[0] };
((Renderer)mainObjectRenderer).materials = materials2;
}
}
}
}
[CompilerGenerated]
private sealed class <WaitForPing_Postfix>d__5 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public IEnumerator result;
public Pinger __instance;
private float <drain>5__1;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <WaitForPing_Postfix>d__5(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
PingerBatteryControl.AllowDrain = true;
<>2__current = result;
<>1__state = 1;
return true;
case 1:
{
<>1__state = -1;
PingerBatteryControl.AllowDrain = false;
if (((GrabbableObject)__instance).insertedBattery == null || MaxUses <= 0)
{
return false;
}
<drain>5__1 = 1f / (float)MaxUses;
Battery insertedBattery = ((GrabbableObject)__instance).insertedBattery;
insertedBattery.charge -= <drain>5__1;
((GrabbableObject)__instance).insertedBattery.charge = Mathf.Clamp01(((GrabbableObject)__instance).insertedBattery.charge);
((GrabbableObject)__instance).insertedBattery.empty = ((GrabbableObject)__instance).insertedBattery.charge <= 0f;
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();
}
}
public static int MaxUses = 11;
public static float PingDuration = 8f;
public static float PingRange = 80f;
[HarmonyPostfix]
[HarmonyPatch("Awake")]
private static void Awake_Postfix(Pinger __instance)
{
__instance.pingTime = PingDuration;
((GrabbableObject)__instance).itemProperties.requiresBattery = true;
Traverse val = Traverse.Create((object)__instance);
if (val.Field("maxPingDistance").FieldExists())
{
val.Field("maxPingDistance").SetValue((object)PingRange);
}
else if (val.Field("pingRange").FieldExists())
{
val.Field("pingRange").SetValue((object)PingRange);
}
}
[IteratorStateMachine(typeof(<WaitForPing_Postfix>d__5))]
[HarmonyPostfix]
[HarmonyPatch("WaitForPing")]
private static IEnumerator WaitForPing_Postfix(IEnumerator result, Pinger __instance)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <WaitForPing_Postfix>d__5(0)
{
result = result,
__instance = __instance
};
}
}
[HarmonyPatch(typeof(GrabbableObject), "Update")]
public static class GrabbableObject_Update_Patch
{
private static void Prefix(GrabbableObject __instance)
{
Pinger val = (Pinger)(object)((__instance is Pinger) ? __instance : null);
if (val != null)
{
((GrabbableObject)val).itemProperties.batteryUsage = float.MaxValue;
}
}
}
[HarmonyPatch(typeof(PlayerControllerB), "Update")]
internal static class RocketLauncherReloadInput
{
private static float nextReloadTime;
private static int FindMissileSlot(PlayerControllerB p)
{
for (int i = 0; i < p.ItemSlots.Length; i++)
{
GrabbableObject val = p.ItemSlots[i];
if ((Object)(object)val != (Object)null && (Object)(object)val.itemProperties != (Object)null && val.itemProperties.itemName == "Missile")
{
return i;
}
}
return -1;
}
private static void Postfix(PlayerControllerB __instance)
{
//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
if (!((NetworkBehaviour)__instance).IsOwner || !((ButtonControl)Keyboard.current.rKey).wasPressedThisFrame)
{
return;
}
GrabbableObject currentlyHeldObjectServer = __instance.currentlyHeldObjectServer;
if ((Object)(object)currentlyHeldObjectServer == (Object)null || (Object)(object)currentlyHeldObjectServer.itemProperties == (Object)null || currentlyHeldObjectServer.itemProperties.itemName != "Rocket Launcher")
{
return;
}
RocketLauncher component = ((Component)currentlyHeldObjectServer).GetComponent<RocketLauncher>();
if ((Object)(object)component == (Object)null)
{
return;
}
RocketLauncherReload component2 = ((Component)component).GetComponent<RocketLauncherReload>();
if (!((Object)(object)component2 == (Object)null))
{
int ammoSlot = FindMissileSlot(__instance);
if (!(Time.unscaledTime < nextReloadTime))
{
nextReloadTime = Time.unscaledTime + 0.5f;
component2.RequestReloadServerRpc(ammoSlot);
}
}
}
}
}
namespace ImprovedLethalThings.patches
{
[HarmonyPatch(typeof(FlareController))]
public static class FlareControllerPatch
{
[HarmonyPostfix]
[HarmonyPatch("Awake")]
public static void EnableFlareShadows(FlareController __instance)
{
Light componentInChildren = ((Component)__instance).GetComponentInChildren<Light>();
if (!((Object)(object)componentInChildren == (Object)null))
{
componentInChildren.shadows = (LightShadows)2;
componentInChildren.shadowStrength = 1f;
componentInChildren.shadowBias = 0.05f;
componentInChildren.shadowNormalBias = 0.4f;
}
}
}
}
namespace ImprovedLethalThings.Networking
{
public class RocketLauncherReload : NetworkBehaviour
{
private static readonly FieldInfo currentAmmoField = typeof(RocketLauncher).GetField("currentAmmo", BindingFlags.Instance | BindingFlags.NonPublic);
[ServerRpc(RequireOwnership = false)]
public void RequestReloadServerRpc(int ammoSlot, ServerRpcParams rpcParams = default(ServerRpcParams))
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_0099: Unknown result type (might be due to invalid IL or missing references)
//IL_00a3: Invalid comparison between Unknown and I4
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
//IL_0139: Unknown result type (might be due to invalid IL or missing references)
//IL_013a: 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_0153: Unknown result type (might be due to invalid IL or missing references)
//IL_0166: Unknown result type (might be due to invalid IL or missing references)
//IL_0168: Unknown result type (might be due to invalid IL or missing references)
//IL_016d: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager == null || !networkManager.IsListening)
{
return;
}
if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
{
FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2278487666u, rpcParams, (RpcDelivery)0);
BytePacker.WriteValueBitPacked(val, ammoSlot);
((NetworkBehaviour)this).__endSendServerRpc(ref val, 2278487666u, rpcParams, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
{
return;
}
base.__rpc_exec_stage = (__RpcExecStage)0;
if (((NetworkBehaviour)this).IsServer)
{
RocketLauncher component = ((Component)this).GetComponent<RocketLauncher>();
if (!((Object)(object)component == (Object)null) && currentAmmoField?.GetValue(component) is NetworkVariable<int> val2 && val2.Value < component.maxAmmo)
{
ulong senderClientId = rpcParams.Receive.SenderClientId;
ConfirmReloadClientRpc(ammoSlot, new ClientRpcParams
{
Send = new ClientRpcSendParams
{
TargetClientIds = new <>z__ReadOnlySingleElementList<ulong>(senderClientId)
}
});
}
}
}
[ClientRpc]
private void ConfirmReloadClientRpc(int ammoSlot, ClientRpcParams _params = default(ClientRpcParams))
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_0099: Unknown result type (might be due to invalid IL or missing references)
//IL_00a3: Invalid comparison between Unknown and I4
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager == null || !networkManager.IsListening)
{
return;
}
if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
{
FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3248320239u, _params, (RpcDelivery)0);
BytePacker.WriteValueBitPacked(val, ammoSlot);
((NetworkBehaviour)this).__endSendClientRpc(ref val, 3248320239u, _params, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
{
return;
}
base.__rpc_exec_stage = (__RpcExecStage)0;
RocketLauncher component = ((Component)this).GetComponent<RocketLauncher>();
if ((Object)(object)component == (Object)null)
{
return;
}
PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
if ((Object)(object)localPlayerController == (Object)null || ammoSlot < 0 || ammoSlot >= localPlayerController.ItemSlots.Length)
{
return;
}
GrabbableObject val2 = localPlayerController.ItemSlots[ammoSlot];
if ((Object)(object)val2 == (Object)null || (Object)(object)val2.itemProperties == (Object)null || val2.itemProperties.itemName != "Missile" || !(currentAmmoField?.GetValue(component) is NetworkVariable<int> val3) || val3.Value >= component.maxAmmo)
{
return;
}
ReloadServerRpc();
localPlayerController.DestroyItemInSlotAndSync(ammoSlot);
AudioSource val4 = ((Component)localPlayerController).GetComponent<AudioSource>() ?? ((Component)localPlayerController).gameObject.AddComponent<AudioSource>();
AssetBundle val5 = AssetBundle.GetAllLoadedAssetBundles().FirstOrDefault((Func<AssetBundle, bool>)((AssetBundle b) => ((Object)b).name == "itemmissile"));
if ((Object)(object)val5 != (Object)null)
{
AudioClip val6 = val5.LoadAsset<AudioClip>("Assets/Missile/reload.wav");
if ((Object)(object)val6 != (Object)null)
{
val4.PlayOneShot(val6);
}
}
}
[ServerRpc(RequireOwnership = false)]
private void ReloadServerRpc()
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Invalid comparison between Unknown and I4
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager == null || !networkManager.IsListening)
{
return;
}
if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
{
ServerRpcParams val = default(ServerRpcParams);
FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2070766885u, val, (RpcDelivery)0);
((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2070766885u, val, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
{
base.__rpc_exec_stage = (__RpcExecStage)0;
RocketLauncher component = ((Component)this).GetComponent<RocketLauncher>();
if (!((Object)(object)component == (Object)null) && currentAmmoField?.GetValue(component) is NetworkVariable<int> val3)
{
SyncAmmoClientRpc(ammo: val3.Value = Mathf.Clamp(val3.Value + 1, 0, component.maxAmmo), rocketNetId: ((NetworkBehaviour)component).NetworkObjectId);
}
}
}
[ClientRpc]
private void SyncAmmoClientRpc(ulong rocketNetId, int ammo)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
//IL_00b0: Invalid comparison between Unknown and I4
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Unknown result type (might be due to invalid IL or missing references)
//IL_00db: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager == null || !networkManager.IsListening)
{
return;
}
if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
{
ClientRpcParams val = default(ClientRpcParams);
FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2330922952u, val, (RpcDelivery)0);
BytePacker.WriteValueBitPacked(val2, rocketNetId);
BytePacker.WriteValueBitPacked(val2, ammo);
((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2330922952u, val, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
{
return;
}
base.__rpc_exec_stage = (__RpcExecStage)0;
if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(rocketNetId, out var value))
{
RocketLauncher component = ((Component)value).GetComponent<RocketLauncher>();
if (!((Object)(object)component == (Object)null) && currentAmmoField?.GetValue(component) is NetworkVariable<int> val3)
{
val3.Value = ammo;
}
}
}
protected override void __initializeVariables()
{
((NetworkBehaviour)this).__initializeVariables();
}
protected override void __initializeRpcs()
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Expected O, but got Unknown
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Expected O, but got Unknown
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Expected O, but got Unknown
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Expected O, but got Unknown
((NetworkBehaviour)this).__registerRpc(2278487666u, new RpcReceiveHandler(__rpc_handler_2278487666), "RequestReloadServerRpc");
((NetworkBehaviour)this).__registerRpc(3248320239u, new RpcReceiveHandler(__rpc_handler_3248320239), "ConfirmReloadClientRpc");
((NetworkBehaviour)this).__registerRpc(2070766885u, new RpcReceiveHandler(__rpc_handler_2070766885), "ReloadServerRpc");
((NetworkBehaviour)this).__registerRpc(2330922952u, new RpcReceiveHandler(__rpc_handler_2330922952), "SyncAmmoClientRpc");
((NetworkBehaviour)this).__initializeRpcs();
}
private static void __rpc_handler_2278487666(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
int ammoSlot = default(int);
ByteUnpacker.ReadValueBitPacked(reader, ref ammoSlot);
ServerRpcParams server = rpcParams.Server;
target.__rpc_exec_stage = (__RpcExecStage)1;
((RocketLauncherReload)(object)target).RequestReloadServerRpc(ammoSlot, server);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
private static void __rpc_handler_3248320239(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
int ammoSlot = default(int);
ByteUnpacker.ReadValueBitPacked(reader, ref ammoSlot);
ClientRpcParams client = rpcParams.Client;
target.__rpc_exec_stage = (__RpcExecStage)1;
((RocketLauncherReload)(object)target).ConfirmReloadClientRpc(ammoSlot, client);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
private static void __rpc_handler_2070766885(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
target.__rpc_exec_stage = (__RpcExecStage)1;
((RocketLauncherReload)(object)target).ReloadServerRpc();
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
private static void __rpc_handler_2330922952(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
ulong rocketNetId = default(ulong);
ByteUnpacker.ReadValueBitPacked(reader, ref rocketNetId);
int ammo = default(int);
ByteUnpacker.ReadValueBitPacked(reader, ref ammo);
target.__rpc_exec_stage = (__RpcExecStage)1;
((RocketLauncherReload)(object)target).SyncAmmoClientRpc(rocketNetId, ammo);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
protected internal override string __getTypeName()
{
return "RocketLauncherReload";
}
}
[HarmonyPatch(typeof(HUDManager), "ChangeControlTipMultiple")]
internal static class RocketLauncherReloadTip
{
private static void Prefix(ref string[] allLines, bool holdingItem, Item itemProperties)
{
if (holdingItem && !((Object)(object)itemProperties == (Object)null) && !(itemProperties.itemName != "Rocket Launcher"))
{
if (allLines == null)
{
allLines = new string[1] { "Reload : [R]" };
return;
}
string[] array = new string[allLines.Length + 1];
allLines.CopyTo(array, 0);
array[^1] = "Reload : [R]";
allLines = array;
}
}
}
}
namespace ImprovedLethalThings.Items
{
public static class MissileRegistration
{
public static void RegisterMissileItem(ImprovedLethalThings p, int cost)
{
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
string text = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)p).Info.Location), "itemmissile");
AssetBundle val = AssetBundle.LoadFromFile(text);
if ((Object)(object)val == (Object)null)
{
return;
}
Item val2 = val.LoadAsset<Item>("Assets/Missile/itemmissile.asset");
GameObject spawnPrefab = val2.spawnPrefab;
ForceScanColorOnItem val3 = spawnPrefab.AddComponent<ForceScanColorOnItem>();
val3.grabbableObject = spawnPrefab.GetComponent<GrabbableObject>() ?? spawnPrefab.GetComponentInChildren<GrabbableObject>();
val3.borderColor = Color.blue;
DawnLib.RegisterNetworkPrefab(spawnPrefab);
DawnLib.DefineItem(NamespacedKeys.Missile, val2, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder b)
{
b.DefineShop((Action<ShopBuilder>)delegate(ShopBuilder s)
{
s.OverrideCost(cost);
});
});
}
}
public static class NamespacedKeys
{
public static NamespacedKey<DawnItemInfo> Missile = NamespacedKey<DawnItemInfo>.From("ImprovedLethalThings", "Missile");
}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlySingleElementList<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
private sealed class Enumerator : IDisposable, IEnumerator, IEnumerator<T>
{
object IEnumerator.Current => _item;
T IEnumerator<T>.Current => _item;
public Enumerator(T item)
{
_item = item;
}
bool IEnumerator.MoveNext()
{
return !_moveNextCalled && (_moveNextCalled = true);
}
void IEnumerator.Reset()
{
_moveNextCalled = false;
}
void IDisposable.Dispose()
{
}
}
int ICollection.Count => 1;
bool ICollection.IsSynchronized => false;
object ICollection.SyncRoot => this;
object IList.this[int index]
{
get
{
if (index != 0)
{
throw new IndexOutOfRangeException();
}
return _item;
}
set
{
throw new NotSupportedException();
}
}
bool IList.IsFixedSize => true;
bool IList.IsReadOnly => true;
int IReadOnlyCollection<T>.Count => 1;
T IReadOnlyList<T>.this[int index]
{
get
{
if (index != 0)
{
throw new IndexOutOfRangeException();
}
return _item;
}
}
int ICollection<T>.Count => 1;
bool ICollection<T>.IsReadOnly => true;
T IList<T>.this[int index]
{
get
{
if (index != 0)
{
throw new IndexOutOfRangeException();
}
return _item;
}
set
{
throw new NotSupportedException();
}
}
public <>z__ReadOnlySingleElementList(T item)
{
_item = item;
}
IEnumerator IEnumerable.GetEnumerator()
{
return new Enumerator(_item);
}
void ICollection.CopyTo(Array array, int index)
{
array.SetValue(_item, index);
}
int IList.Add(object value)
{
throw new NotSupportedException();
}
void IList.Clear()
{
throw new NotSupportedException();
}
bool IList.Contains(object value)
{
return EqualityComparer<T>.Default.Equals(_item, (T)value);
}
int IList.IndexOf(object value)
{
return (!EqualityComparer<T>.Default.Equals(_item, (T)value)) ? (-1) : 0;
}
void IList.Insert(int index, object value)
{
throw new NotSupportedException();
}
void IList.Remove(object value)
{
throw new NotSupportedException();
}
void IList.RemoveAt(int index)
{
throw new NotSupportedException();
}
IEnumerator<T> IEnumerable<T>.GetEnumerator()
{
return new Enumerator(_item);
}
void ICollection<T>.Add(T item)
{
throw new NotSupportedException();
}
void ICollection<T>.Clear()
{
throw new NotSupportedException();
}
bool ICollection<T>.Contains(T item)
{
return EqualityComparer<T>.Default.Equals(_item, item);
}
void ICollection<T>.CopyTo(T[] array, int arrayIndex)
{
array[arrayIndex] = _item;
}
bool ICollection<T>.Remove(T item)
{
throw new NotSupportedException();
}
int IList<T>.IndexOf(T item)
{
return (!EqualityComparer<T>.Default.Equals(_item, item)) ? (-1) : 0;
}
void IList<T>.Insert(int index, T item)
{
throw new NotSupportedException();
}
void IList<T>.RemoveAt(int index)
{
throw new NotSupportedException();
}
}
namespace __GEN
{
internal class NetworkVariableSerializationHelper
{
[RuntimeInitializeOnLoadMethod]
internal static void InitializeSerialization()
{
}
}
}
namespace ImprovedLethalThings.NetcodePatcher
{
[AttributeUsage(AttributeTargets.Module)]
internal class NetcodePatchedAssemblyAttribute : Attribute
{
}
}
