using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using BetterLadders.Compatibility;
using BetterLadders.Config;
using BetterLadders.Patches;
using GameNetcodeStuff;
using HarmonyLib;
using LethalConfig;
using LethalConfig.ConfigItems;
using LethalConfig.ConfigItems.Options;
using LobbyCompatibility.Enums;
using LobbyCompatibility.Features;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem.Utilities;
using UnityEngine.SceneManagement;
using e3s1.BetterLadders.NetcodePatcher;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("AmazingAssets.TerrainToMesh")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp-firstpass")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("BMX.LobbyCompatibility")]
[assembly: IgnoresAccessChecksTo("ClientNetworkTransform")]
[assembly: IgnoresAccessChecksTo("com.olegknyazev.softmask")]
[assembly: IgnoresAccessChecksTo("DissonanceVoip")]
[assembly: IgnoresAccessChecksTo("EasyTextEffects")]
[assembly: IgnoresAccessChecksTo("Facepunch Transport for Netcode for GameObjects")]
[assembly: IgnoresAccessChecksTo("Facepunch.Steamworks.Win64")]
[assembly: IgnoresAccessChecksTo("LethalConfig")]
[assembly: IgnoresAccessChecksTo("Unity.AI.Navigation")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging.DocCodeExamples")]
[assembly: IgnoresAccessChecksTo("Unity.Burst")]
[assembly: IgnoresAccessChecksTo("Unity.Burst.Unsafe")]
[assembly: IgnoresAccessChecksTo("Unity.Collections")]
[assembly: IgnoresAccessChecksTo("Unity.Collections.LowLevel.ILSupport")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem.ForUI")]
[assembly: IgnoresAccessChecksTo("Unity.Jobs")]
[assembly: IgnoresAccessChecksTo("Unity.Mathematics")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.Common")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.MetricTypes")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStats")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Component")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Implementation")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsReporting")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkProfiler.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkSolutionInterface")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Networking.Transport")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Csg")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.KdTree")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Poly2Tri")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Stl")]
[assembly: IgnoresAccessChecksTo("Unity.Profiling.Core")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.ShaderLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Config.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.ShaderGraph.ShaderGraphLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Authentication")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Analytics")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Device")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Networking")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Registration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Scheduler")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Telemetry")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Threading")]
[assembly: IgnoresAccessChecksTo("Unity.Services.QoS")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Relay")]
[assembly: IgnoresAccessChecksTo("Unity.TextMeshPro")]
[assembly: IgnoresAccessChecksTo("Unity.Timeline")]
[assembly: IgnoresAccessChecksTo("Unity.VisualEffectGraph.Runtime")]
[assembly: IgnoresAccessChecksTo("UnityEngine.ARModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.NVIDIAModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.UI")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("e3s1.BetterLadders")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("[v73] Configurable climbing speed, extension ladder time, climbing with two-handed items, and more")]
[assembly: AssemblyFileVersion("1.5.0.0")]
[assembly: AssemblyInformationalVersion("1.5.0+3378133b8109028859a5c07511c02330c0462007")]
[assembly: AssemblyProduct("BetterLadders")]
[assembly: AssemblyTitle("e3s1.BetterLadders")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/e3s1/BetterLadders")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.5.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.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace BetterLadders
{
[BepInPlugin("e3s1.BetterLadders", "BetterLadders", "1.5.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class BetterLaddersPlugin : BaseUnityPlugin
{
private const string LethalConfigGuid = "ainavt.lc.lethalconfig";
private const string LobbyCompatibilityGuid = "BMX.LobbyCompatibility";
private readonly Harmony _harmony = new Harmony("e3s1.BetterLadders");
internal static ManualLogSource Logger { get; private set; }
private void Awake()
{
Logger = ((BaseUnityPlugin)this).Logger;
NetcodePatcher();
if (Chainloader.PluginInfos.ContainsKey("ainavt.lc.lethalconfig"))
{
Logger.LogInfo((object)"LethalConfig detected");
LethalConfig.Init();
}
if (Chainloader.PluginInfos.ContainsKey("BMX.LobbyCompatibility"))
{
Logger.LogInfo((object)"LobbyCompatibility detected, registering plugin...");
LobbyCompatibility.Init(((BaseUnityPlugin)this).Info.Metadata);
}
new LocalConfig(((BaseUnityPlugin)this).Config);
SceneManager.sceneLoaded += SyncedConfig.Initialize;
_harmony.PatchAll(typeof(AllowTwoHanded));
_harmony.PatchAll(typeof(ClimbSpeed));
_harmony.PatchAll(typeof(ExtensionLadderTime));
_harmony.PatchAll(typeof(HideItems));
_harmony.PatchAll(typeof(HoldToPickup));
_harmony.PatchAll(typeof(HoverTip));
_harmony.PatchAll(typeof(KillTrigger));
Logger.LogInfo((object)"Running transpilers...");
if (!LocalConfig.Instance.DebugMode.Value)
{
Logger.LogInfo((object)"Not logging IL code, DebugMode is disabled");
}
_harmony.PatchAll(typeof(ExtensionLadderDelay));
_harmony.PatchAll(typeof(ExtensionLadderSpeed));
_harmony.PatchAll(typeof(TransitionSpeed));
Logger.LogInfo((object)"Finished loading");
}
private static void NetcodePatcher()
{
foreach (Type item in Assembly.GetExecutingAssembly().GetTypes().Where(delegate(Type t)
{
string? @namespace = t.Namespace;
return @namespace == null || !@namespace.StartsWith("BetterLadders.Compatibility");
}))
{
MethodInfo[] methods = item.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
foreach (MethodInfo methodInfo in methods)
{
if (methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false).Length != 0)
{
methodInfo.Invoke(null, null);
}
}
}
}
}
public static class TranspilerHelper
{
public static IEnumerable<CodeInstruction> Patch(IEnumerable<CodeInstruction> instructions, Func<List<CodeInstruction>, List<(int logStartIndex, int logEndIndex)>, bool>[] patches, [CallerMemberName] string memberName = "")
{
BetterLaddersPlugin.Logger.LogInfo((object)("Starting " + memberName));
List<CodeInstruction> code = new List<CodeInstruction>(instructions);
for (int i = 0; i < patches.Length; i++)
{
try
{
List<(int, int)> list = new List<(int, int)>();
if (!patches[i](code, list))
{
BetterLaddersPlugin.Logger.LogError((object)$"No IL match found for patch #{i} in {memberName}");
continue;
}
BetterLaddersPlugin.Logger.LogInfo((object)$"Completed applying patch #{i} in {memberName}");
if (!LocalConfig.Instance.DebugMode.Value)
{
continue;
}
int num = list.Select<(int, int), List<CodeInstruction>>(((int logStartIndex, int logEndIndex) s) => code.GetRange(s.logStartIndex, s.logEndIndex - s.logStartIndex)).Max((List<CodeInstruction> codes) => codes.Max((CodeInstruction c) => ((object)c).ToString().Length));
int count = num + 2;
for (int j = 0; j < list.Count; j++)
{
(int, int) tuple = list[j];
int item = tuple.Item1;
int item2 = tuple.Item2;
string text = "╞═╡";
if (j == 0)
{
text = "┌─┐";
}
BetterLaddersPlugin.Logger.LogInfo((object)(text[0] + new string(text[1], count) + text[2]));
for (int k = item; k < item2; k++)
{
string text2 = ((code[k].operand == null) ? code[k].opcode.ToString() : ((object)code[k]).ToString());
BetterLaddersPlugin.Logger.LogInfo((object)("│ " + text2.PadRight(num) + " │"));
}
if (j == list.Count - 1)
{
BetterLaddersPlugin.Logger.LogInfo((object)("└" + new string('─', count) + "┘"));
}
}
}
catch (Exception arg)
{
BetterLaddersPlugin.Logger.LogError((object)$"Error running patch #{i} in {memberName}: {arg}");
}
}
BetterLaddersPlugin.Logger.LogInfo((object)("Finished all patches in " + memberName));
BetterLaddersPlugin.Logger.LogInfo((object)"");
return code;
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "e3s1.BetterLadders";
public const string PLUGIN_NAME = "BetterLadders";
public const string PLUGIN_VERSION = "1.5.0";
}
}
namespace BetterLadders.Patches
{
internal static class AllowTwoHanded
{
[HarmonyPrefix]
[HarmonyPatch(typeof(PlayerControllerB), "Interact_performed")]
private static void LadderTwoHandedAccessPrefix(PlayerControllerB __instance)
{
InteractTrigger hoveringOverTrigger = __instance.hoveringOverTrigger;
if (!((Object)(object)hoveringOverTrigger == (Object)null) && hoveringOverTrigger.isLadder)
{
hoveringOverTrigger.specialCharacterAnimation = !(hoveringOverTrigger.twoHandedItemAllowed = LocalConfig.Instance.AllowTwoHanded.Value || __instance.isClimbingLadder);
}
}
}
internal static class ClimbSpeed
{
private class TimeoutResult
{
public bool TimedOut;
}
[CompilerGenerated]
private sealed class <>c__DisplayClass7_0
{
public PlayerControllerB player;
internal bool <SetClimbSpeed>b__0()
{
player.climbSpeed = _vanillaClimbSpeed * LocalConfig.Instance.ClimbSpeedMultiplier.Value;
if (player.isSprinting)
{
PlayerControllerB obj = player;
obj.climbSpeed *= LocalConfig.Instance.SprintingClimbSpeedMultiplier.Value;
}
return player.isClimbingLadder;
}
}
[CompilerGenerated]
private sealed class <>c__DisplayClass8_0
{
public PlayerControllerB player;
internal bool <SetAnimationSpeed>b__0()
{
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
float @float = player.playerBodyAnimator.GetFloat(AnimationSpeed);
if (@float == 0f)
{
return player.isClimbingLadder;
}
bool flag = (Object)(object)player == (Object)(object)GameNetworkManager.Instance.localPlayerController;
if (flag && player.moveInputVector.y == 0f)
{
player.playerBodyAnimator.SetFloat(AnimationSpeed, 0f);
return player.isClimbingLadder;
}
bool num;
if (!flag)
{
AnimatorStateInfo currentAnimatorStateInfo = player.playerBodyAnimator.GetCurrentAnimatorStateInfo(0);
num = ((AnimatorStateInfo)(ref currentAnimatorStateInfo)).IsTag("Sprinting");
}
else
{
num = player.isSprinting;
}
float num2 = LocalConfig.Instance.ClimbSpeedMultiplier.Value;
if (num)
{
num2 *= LocalConfig.Instance.SprintingClimbSpeedMultiplier.Value;
}
int num3 = ((@float > 0f) ? 1 : ((@float < 0f) ? (-1) : 0));
int num4 = num3;
player.playerBodyAnimator.SetFloat(AnimationSpeed, num2 * (float)num4);
return player.isClimbingLadder;
}
}
[CompilerGenerated]
private sealed class <SetAnimationSpeed>d__8 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public PlayerControllerB player;
private <>c__DisplayClass8_0 <>8__1;
private TimeoutResult <timeoutResult>5__2;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <SetAnimationSpeed>d__8(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>8__1 = null;
<timeoutResult>5__2 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
//IL_00c4: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>8__1 = new <>c__DisplayClass8_0();
<>8__1.player = player;
BetterLaddersPlugin.Logger.LogInfo((object)("Starting SetAnimationSpeed coroutine for " + <>8__1.player.playerUsername));
<timeoutResult>5__2 = new TimeoutResult();
<>2__current = Timeout(<>8__1.player, <timeoutResult>5__2);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if (<timeoutResult>5__2.TimedOut)
{
return false;
}
<>2__current = (object)new WaitWhile((Func<bool>)delegate
{
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
float @float = <>8__1.player.playerBodyAnimator.GetFloat(AnimationSpeed);
if (@float == 0f)
{
return <>8__1.player.isClimbingLadder;
}
bool flag = (Object)(object)<>8__1.player == (Object)(object)GameNetworkManager.Instance.localPlayerController;
if (flag && <>8__1.player.moveInputVector.y == 0f)
{
<>8__1.player.playerBodyAnimator.SetFloat(AnimationSpeed, 0f);
return <>8__1.player.isClimbingLadder;
}
bool num;
if (!flag)
{
AnimatorStateInfo currentAnimatorStateInfo = <>8__1.player.playerBodyAnimator.GetCurrentAnimatorStateInfo(0);
num = ((AnimatorStateInfo)(ref currentAnimatorStateInfo)).IsTag("Sprinting");
}
else
{
num = <>8__1.player.isSprinting;
}
float num2 = LocalConfig.Instance.ClimbSpeedMultiplier.Value;
if (num)
{
num2 *= LocalConfig.Instance.SprintingClimbSpeedMultiplier.Value;
}
int num3 = ((@float > 0f) ? 1 : ((@float < 0f) ? (-1) : 0));
int num4 = num3;
<>8__1.player.playerBodyAnimator.SetFloat(AnimationSpeed, num2 * (float)num4);
return <>8__1.player.isClimbingLadder;
});
<>1__state = 2;
return true;
case 2:
<>1__state = -1;
BetterLaddersPlugin.Logger.LogInfo((object)("Finished SetAnimationSpeed coroutine for " + <>8__1.player.playerUsername));
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 <SetClimbSpeed>d__7 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public PlayerControllerB player;
private <>c__DisplayClass7_0 <>8__1;
private TimeoutResult <timeoutResult>5__2;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <SetClimbSpeed>d__7(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>8__1 = null;
<timeoutResult>5__2 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
//IL_00c4: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>8__1 = new <>c__DisplayClass7_0();
<>8__1.player = player;
BetterLaddersPlugin.Logger.LogInfo((object)("Starting SetClimbSpeed coroutine for " + <>8__1.player.playerUsername));
<timeoutResult>5__2 = new TimeoutResult();
<>2__current = Timeout(<>8__1.player, <timeoutResult>5__2);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if (<timeoutResult>5__2.TimedOut)
{
return false;
}
<>2__current = (object)new WaitWhile((Func<bool>)delegate
{
<>8__1.player.climbSpeed = _vanillaClimbSpeed * LocalConfig.Instance.ClimbSpeedMultiplier.Value;
if (<>8__1.player.isSprinting)
{
PlayerControllerB obj = <>8__1.player;
obj.climbSpeed *= LocalConfig.Instance.SprintingClimbSpeedMultiplier.Value;
}
return <>8__1.player.isClimbingLadder;
});
<>1__state = 2;
return true;
case 2:
<>1__state = -1;
BetterLaddersPlugin.Logger.LogInfo((object)("Finished SetClimbSpeed coroutine for " + <>8__1.player.playerUsername));
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 <Timeout>d__6 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public PlayerControllerB player;
public TimeoutResult timeoutResult;
private float <timeWaiting>5__2;
private float <timeout>5__3;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <Timeout>d__6(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;
<timeWaiting>5__2 = 0f;
<timeout>5__3 = 1f / LocalConfig.Instance.TransitionSpeedMultiplier.Value;
break;
case 1:
<>1__state = -1;
break;
}
if (!player.isClimbingLadder)
{
<timeWaiting>5__2 += Time.deltaTime;
if (!(<timeWaiting>5__2 > <timeout>5__3))
{
<>2__current = null;
<>1__state = 1;
return true;
}
BetterLaddersPlugin.Logger.LogInfo((object)$"Coroutine timed out for {player.playerUsername} after {<timeWaiting>5__2}s (max {<timeout>5__3}s)");
timeoutResult.TimedOut = true;
}
BetterLaddersPlugin.Logger.LogInfo((object)$"Waited {<timeWaiting>5__2}s for {player.playerUsername} to start climbing ladder");
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 _vanillaClimbSpeed = float.NaN;
private static readonly int AnimationSpeed = Animator.StringToHash("animationSpeed");
[HarmonyPostfix]
[HarmonyPatch(typeof(PlayerControllerB), "Awake")]
private static void GetVanillaClimbSpeedPatch(PlayerControllerB __instance)
{
if (float.IsNaN(_vanillaClimbSpeed))
{
_vanillaClimbSpeed = __instance.climbSpeed;
BetterLaddersPlugin.Logger.LogInfo((object)$"Vanilla climb speed: {_vanillaClimbSpeed}");
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(InteractTrigger), "SetUsingLadderOnLocalClient")]
private static void LadderAnimationSpeedPatch(bool isUsing)
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
if (isUsing)
{
PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
((MonoBehaviour)localPlayerController).StartCoroutine(SetAnimationSpeed(localPlayerController));
if (((NetworkBehaviour)SyncedConfig.Instance).IsSpawned)
{
SyncedConfig.Instance.RequestStartChangeAnimationSpeedRpc(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)localPlayerController));
}
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(InteractTrigger), "SetUsingLadderOnLocalClient")]
private static void LadderClimbSpeedPatch(bool isUsing)
{
if (isUsing)
{
PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
((MonoBehaviour)localPlayerController).StartCoroutine(SetClimbSpeed(localPlayerController));
}
}
[IteratorStateMachine(typeof(<Timeout>d__6))]
private static IEnumerator Timeout(PlayerControllerB player, TimeoutResult timeoutResult)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <Timeout>d__6(0)
{
player = player,
timeoutResult = timeoutResult
};
}
[IteratorStateMachine(typeof(<SetClimbSpeed>d__7))]
private static IEnumerator SetClimbSpeed(PlayerControllerB player)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <SetClimbSpeed>d__7(0)
{
player = player
};
}
[IteratorStateMachine(typeof(<SetAnimationSpeed>d__8))]
internal static IEnumerator SetAnimationSpeed(PlayerControllerB player)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <SetAnimationSpeed>d__8(0)
{
player = player
};
}
}
public static class ExtensionLadderDelay
{
private static readonly ConstructorInfo WaitForSecondsConstructor = AccessTools.Constructor(typeof(WaitForSeconds), new Type[1] { typeof(float) }, false);
private static readonly MethodInfo ExtensionDelayGetter = AccessTools.PropertyGetter(typeof(ExtensionLadderDelay), "ExtensionDelay");
private static readonly MethodInfo FallDelayGetter = AccessTools.PropertyGetter(typeof(ExtensionLadderDelay), "FallDelay");
private static float ExtensionDelay => LocalConfig.Instance.ExtensionDelay.Value;
private static float FallDelay => LocalConfig.Instance.FallDelay.Value;
[HarmonyTranspiler]
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
internal static IEnumerable<CodeInstruction> ExtensionDelayTranspiler(IEnumerable<CodeInstruction> instructions)
{
return CommonTranspiler(instructions, LocalConfig.Instance.ExtensionDelay.VanillaValue, ExtensionDelayGetter, "ExtensionDelayTranspiler");
}
[HarmonyTranspiler]
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
internal static IEnumerable<CodeInstruction> FallDelayTranspiler(IEnumerable<CodeInstruction> instructions)
{
return CommonTranspiler(instructions, LocalConfig.Instance.FallDelay.VanillaValue, FallDelayGetter, "FallDelayTranspiler");
}
private static IEnumerable<CodeInstruction> CommonTranspiler(IEnumerable<CodeInstruction> instructions, float vanillaValue, MethodInfo getter, [CallerMemberName] string memberName = "")
{
return TranspilerHelper.Patch(instructions, new Func<List<CodeInstruction>, List<(int, int)>, bool>[1]
{
delegate(List<CodeInstruction> code, List<(int logStartIndex, int logEndIndex)> logIndices)
{
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_00a3: Expected O, but got Unknown
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: Expected O, but got Unknown
for (int i = 0; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Ldc_R4 && code[i].operand is float num && num == vanillaValue && code[i + 1].opcode == OpCodes.Newobj && code[i + 1].operand is ConstructorInfo constructorInfo && constructorInfo == WaitForSecondsConstructor)
{
code.InsertRange(i + 1, new <>z__ReadOnlyArray<CodeInstruction>((CodeInstruction[])(object)new CodeInstruction[2]
{
new CodeInstruction(OpCodes.Pop, (object)null),
new CodeInstruction(OpCodes.Call, (object)getter)
}));
logIndices.Add((i, i + 3));
return true;
}
}
return false;
}
}, memberName);
}
}
public static class ExtensionLadderSpeed
{
private static readonly MethodInfo ExtensionSpeedMultiplierGetter = AccessTools.PropertyGetter(typeof(ExtensionLadderSpeed), "ExtensionSpeedMultiplier");
private static readonly MethodInfo FallSpeedMultiplierGetter = AccessTools.PropertyGetter(typeof(ExtensionLadderSpeed), "FallSpeedMultiplier");
private static float ExtensionSpeedMultiplier => LocalConfig.Instance.ExtensionSpeedMultiplier.Value;
private static float FallSpeedMultiplier => LocalConfig.Instance.FallSpeedMultiplier.Value;
[HarmonyTranspiler]
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
internal static IEnumerable<CodeInstruction> ExtensionSpeedTranspiler(IEnumerable<CodeInstruction> instructions)
{
return CommonTranspiler(instructions, ExtensionSpeedMultiplierGetter, "ExtensionSpeedTranspiler");
}
[HarmonyTranspiler]
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
internal static IEnumerable<CodeInstruction> FallSpeedTranspiler(IEnumerable<CodeInstruction> instructions)
{
return CommonTranspiler(instructions, FallSpeedMultiplierGetter, "FallSpeedTranspiler");
}
private static IEnumerable<CodeInstruction> CommonTranspiler(IEnumerable<CodeInstruction> instructions, MethodInfo getter, [CallerMemberName] string memberName = "")
{
return TranspilerHelper.Patch(instructions, new Func<List<CodeInstruction>, List<(int, int)>, bool>[1]
{
delegate(List<CodeInstruction> code, List<(int logStartIndex, int logEndIndex)> logIndices)
{
//IL_0105: Unknown result type (might be due to invalid IL or missing references)
//IL_010b: Expected O, but got Unknown
//IL_0113: Unknown result type (might be due to invalid IL or missing references)
//IL_0119: Expected O, but got Unknown
for (int i = 0; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Ldfld && code[i].operand is FieldInfo fieldInfo && fieldInfo.Name.Contains("speedMultiplier"))
{
for (int j = i; j < i + 10 && j < code.Count; j++)
{
if (code[j - 1].opcode != OpCodes.Call && code[j].opcode == OpCodes.Mul && code[j + 1].opcode == OpCodes.Add && code[j + 2].opcode == OpCodes.Stfld && code[j + 2].operand is FieldInfo fieldInfo2 && fieldInfo2.Name.Contains("speedMultiplier"))
{
code.InsertRange(j + 1, new <>z__ReadOnlyArray<CodeInstruction>((CodeInstruction[])(object)new CodeInstruction[2]
{
new CodeInstruction(OpCodes.Call, (object)getter),
new CodeInstruction(OpCodes.Mul, (object)null)
}));
logIndices.Add((i, j + 5));
return true;
}
}
}
}
return false;
}
}, memberName);
}
}
internal static class ExtensionLadderTime
{
[HarmonyPrefix]
[HarmonyPatch(typeof(ExtensionLadderItem), "StartLadderAnimation")]
private static void ExtensionTimePatch(ref float ___ladderTimer)
{
float num = ((!(LocalConfig.Instance.ExtensionTime.Value <= 0f)) ? (LocalConfig.Instance.ExtensionTime.VanillaValue - LocalConfig.Instance.ExtensionTime.Value) : float.MinValue);
___ladderTimer = num;
}
}
internal static class HideItems
{
[HarmonyPostfix]
[HarmonyPatch(typeof(InteractTrigger), "SetUsingLadderOnLocalClient")]
private static void SetVisibilityOnStartClimb(InteractTrigger __instance, bool isUsing)
{
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
if (!((Object)(object)localPlayerController.currentlyHeldObjectServer == (Object)null))
{
bool flag = !isUsing;
BetterLaddersPlugin.Logger.LogInfo((object)"Toggling visibility for held item");
if ((LocalConfig.Instance.HideOneHanded.Value && !localPlayerController.twoHanded) || (LocalConfig.Instance.HideTwoHanded.Value && localPlayerController.twoHanded))
{
localPlayerController.currentlyHeldObjectServer.EnableItemMeshes(flag);
}
if (((NetworkBehaviour)SyncedConfig.Instance).IsSpawned)
{
SyncedConfig.Instance.RequestChangeItemVisibilityRpc(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)localPlayerController.currentlyHeldObjectServer), flag);
}
}
}
}
internal static class HoldToPickup
{
private static bool _canPickupLadder;
[HarmonyPrefix]
[HarmonyPatch(typeof(PlayerControllerB), "BeginGrabObject")]
private static bool ControlExtLadderPickup(PlayerControllerB __instance)
{
if (!LocalConfig.Instance.HoldToPickup.Value)
{
return true;
}
if (!LookingAtGrabbableExtLadder(__instance, out var extLadderObj))
{
return true;
}
if ((Object)(object)extLadderObj == (Object)null || !extLadderObj.ladderActivated)
{
return true;
}
if (!_canPickupLadder)
{
return false;
}
_canPickupLadder = false;
return true;
}
[HarmonyPostfix]
[HarmonyPatch(typeof(PlayerControllerB), "ClickHoldInteraction")]
private static void ShowHoldInteractHUD(PlayerControllerB __instance)
{
if (LocalConfig.Instance.HoldToPickup.Value && !Object.op_Implicit((Object)(object)__instance.hoveringOverTrigger))
{
ExtensionLadderItem extLadderObj;
if (!IngamePlayerSettings.Instance.playerInput.actions.FindAction("Interact", false).IsPressed())
{
HUDManager.Instance.holdFillAmount = 0f;
}
else if (LookingAtGrabbableExtLadder(__instance, out extLadderObj) && (Object)(object)extLadderObj != (Object)null && extLadderObj.ladderActivated && HUDManager.Instance.HoldInteractionFill(LocalConfig.Instance.HoldTime.Value, 1f))
{
_canPickupLadder = true;
__instance.BeginGrabObject();
}
}
}
[HarmonyPrefix]
[HarmonyPatch(typeof(PlayerControllerB), "StopHoldInteractionOnTrigger")]
private static bool StopHoldInteractionOnTrigger(PlayerControllerB __instance)
{
if (!LocalConfig.Instance.HoldToPickup.Value)
{
return true;
}
if (LookingAtGrabbableExtLadder(__instance, out var extLadderObj))
{
if ((Object)(object)extLadderObj != (Object)null && extLadderObj.ladderActivated)
{
if (IngamePlayerSettings.Instance.playerInput.actions.FindAction("Interact", false).IsPressed())
{
return false;
}
HUDManager.Instance.holdFillAmount = 0f;
}
}
else
{
HUDManager.Instance.holdFillAmount = 0f;
}
if ((Object)(object)__instance.previousHoveringOverTrigger != (Object)null)
{
__instance.previousHoveringOverTrigger.StopInteraction();
}
if ((Object)(object)__instance.hoveringOverTrigger != (Object)null)
{
__instance.hoveringOverTrigger.StopInteraction();
}
return false;
}
private static bool LookingAtGrabbableExtLadder(PlayerControllerB player, out ExtensionLadderItem extLadderObj)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
RaycastHit val = default(RaycastHit);
bool flag = Physics.Raycast(player.interactRay, ref val, player.grabDistance, player.interactableObjectsMask) && ((Component)((RaycastHit)(ref val)).collider).gameObject.layer != 8;
if (flag)
{
extLadderObj = ((Component)((RaycastHit)(ref val)).collider).gameObject.GetComponent<ExtensionLadderItem>();
if (player.twoHanded || ((Object)(object)extLadderObj != (Object)null && !((GrabbableObject)extLadderObj).grabbable))
{
return false;
}
}
else
{
extLadderObj = null;
}
return flag;
}
}
internal static class HoverTip
{
private static bool? _wasTwoHanded;
[HarmonyPrefix]
[HarmonyPatch(typeof(PlayerControllerB), "SetHoverTipAndCurrentInteractTrigger")]
private static void LadderHoverTipPrefix(PlayerControllerB __instance)
{
if (!((Object)(object)__instance.hoveringOverTrigger == (Object)null) && __instance.hoveringOverTrigger.isLadder && __instance.isHoldingInteract && LocalConfig.Instance.AllowTwoHanded.Value && __instance.twoHanded)
{
_wasTwoHanded = true;
__instance.twoHanded = false;
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(PlayerControllerB), "SetHoverTipAndCurrentInteractTrigger")]
private static void LadderHoverTipPostfix(PlayerControllerB __instance)
{
if (_wasTwoHanded.HasValue)
{
__instance.twoHanded = _wasTwoHanded.Value;
_wasTwoHanded = null;
}
}
}
internal static class KillTrigger
{
[HarmonyPrefix]
[HarmonyPatch(typeof(ExtensionLadderItem), "StartLadderAnimation")]
private static void KillTriggerPatch(ref Collider ___killTrigger)
{
((Component)___killTrigger).gameObject.SetActive(LocalConfig.Instance.EnableKillTrigger.Value);
}
}
internal static class TransitionSpeed
{
private static readonly MethodInfo DeltaTimeGetter = AccessTools.PropertyGetter(typeof(Time), "deltaTime");
private static readonly MethodInfo MultiplierGetter = AccessTools.PropertyGetter(typeof(TransitionSpeed), "Multiplier");
public static float Multiplier => LocalConfig.Instance.TransitionSpeedMultiplier.Value;
[HarmonyTranspiler]
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
internal static IEnumerable<CodeInstruction> TransitionSpeedTranspiler(IEnumerable<CodeInstruction> instructions)
{
return TranspilerHelper.Patch(instructions, new Func<List<CodeInstruction>, List<(int, int)>, bool>[1]
{
delegate(List<CodeInstruction> code, List<(int logStartIndex, int logEndIndex)> logIndices)
{
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Expected O, but got Unknown
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: Expected O, but got Unknown
int num = 0;
for (int i = 0; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Call && code[i].operand is MethodInfo methodInfo && methodInfo == DeltaTimeGetter)
{
code.Insert(i + 1, new CodeInstruction(OpCodes.Call, (object)MultiplierGetter));
code.Insert(i + 2, new CodeInstruction(OpCodes.Mul, (object)null));
num++;
logIndices.Add((i, i + 3));
}
}
return num > 0;
}
}, "TransitionSpeedTranspiler");
}
}
}
namespace BetterLadders.Config
{
[AttributeUsage(AttributeTargets.Class, Inherited = false)]
public sealed class SourceGenAttribute : Attribute
{
public SourceGenAttribute(Type targetFieldType, Type targetClassType)
{
}
}
public abstract class CustomConfigEntry<T>
{
public ConfigEntry<T> ConfigEntry;
public virtual T Value { get; }
protected CustomConfigEntry(ConfigFile configFile, string section, string key, T defaultValue, ConfigDescription configDescription)
{
ConfigEntry = configFile.Bind<T>(section, key, defaultValue, configDescription);
}
protected abstract void LethalConfigCompat();
protected void Init()
{
if (LethalConfig.IsInstalled)
{
LethalConfigCompat();
}
}
}
[SourceGen(typeof(SyncedConfigEntry<>), typeof(SyncedConfig))]
public class LocalConfig
{
public readonly SyncedConfigEntry<float> ClimbSpeedMultiplier;
public readonly SyncedConfigEntry<float> SprintingClimbSpeedMultiplier;
public readonly SyncedConfigEntry<float> TransitionSpeedMultiplier;
public readonly SyncedConfigEntry<bool> AllowTwoHanded;
public readonly LocalConfigEntry<bool> ScaleAnimationSpeed;
public readonly LocalConfigEntry<bool> HideOneHanded;
public readonly LocalConfigEntry<bool> HideTwoHanded;
public readonly SyncedConfigEntry<float> ExtensionTime;
public readonly SyncedConfigEntry<float> ExtensionSpeedMultiplier;
public readonly SyncedConfigEntry<float> ExtensionDelay;
public readonly SyncedConfigEntry<float> FallSpeedMultiplier;
public readonly SyncedConfigEntry<float> FallDelay;
public readonly SyncedConfigEntry<bool> EnableKillTrigger;
public readonly LocalConfigEntry<bool> HoldToPickup;
public readonly LocalConfigEntry<float> HoldTime;
public readonly LocalConfigEntry<bool> DebugMode;
public static LocalConfig Instance { get; private set; }
internal LocalConfig(ConfigFile configFile)
{
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Expected O, but got Unknown
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: Expected O, but got Unknown
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Expected O, but got Unknown
//IL_0168: Unknown result type (might be due to invalid IL or missing references)
//IL_0177: Expected O, but got Unknown
//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
//IL_01b5: Expected O, but got Unknown
//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
//IL_01f3: Expected O, but got Unknown
//IL_0222: Unknown result type (might be due to invalid IL or missing references)
//IL_0231: Expected O, but got Unknown
//IL_0260: Unknown result type (might be due to invalid IL or missing references)
//IL_026f: Expected O, but got Unknown
//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
//IL_02e1: Expected O, but got Unknown
Instance = this;
configFile.SaveOnConfigSet = false;
ClimbSpeedMultiplier = new SyncedConfigEntry<float>(configFile, "General", "ClimbSpeedMultiplier", 1f, new ConfigDescription("Ladder climb speed multiplier (1 in vanilla)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 10f), Array.Empty<object>()), 1f);
SprintingClimbSpeedMultiplier = new SyncedConfigEntry<float>(configFile, "General", "SprintingClimbSpeedMultiplier", 1.5f, new ConfigDescription("Additional climb speed multiplier while sprinting (1 in vanilla)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 10f), Array.Empty<object>()), 1f);
TransitionSpeedMultiplier = new SyncedConfigEntry<float>(configFile, "General", "TransitionSpeedMultiplier", 1f, new ConfigDescription("Ladder enter/exit animation speed multiplier (1 in vanilla)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 10f), Array.Empty<object>()), 1f);
AllowTwoHanded = new SyncedConfigEntry<bool>(configFile, "General", "AllowTwoHanded", defaultValue: true, "Whether ladders can be climbed while carrying a two-handed object (false in vanilla)", vanillaValue: false);
ScaleAnimationSpeed = new LocalConfigEntry<bool>(configFile, "General", "ScaleAnimationSpeed", defaultValue: true, "Whether the climbing animation is scaled to the climbing speed (false in vanilla)");
HideOneHanded = new LocalConfigEntry<bool>(configFile, "General", "HideOneHanded", defaultValue: true, "Whether one-handed items should be hidden while climbing a ladder (false in vanilla)");
HideTwoHanded = new LocalConfigEntry<bool>(configFile, "General", "HideTwoHanded", defaultValue: true, "Whether two-handed items should be hidden while climbing a ladder (false in vanilla)");
ExtensionTime = new SyncedConfigEntry<float>(configFile, "Extension Ladders", "ExtensionTime", 0f, new ConfigDescription("How long extension ladders should stay extended, in seconds (0 for permanent) (20 in vanilla)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3600f), Array.Empty<object>()), 20f);
ExtensionSpeedMultiplier = new SyncedConfigEntry<float>(configFile, "Extension Ladders", "ExtensionSpeedMultiplier", 1f, new ConfigDescription("Multiplies how fast the ladder extends once activated (1 in vanilla)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 100f), Array.Empty<object>()), 1f);
ExtensionDelay = new SyncedConfigEntry<float>(configFile, "Extension Ladders", "ExtensionDelay", 1f, new ConfigDescription("How long before the ladder begins to extend once activated, in seconds (1 in vanilla)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 15f), Array.Empty<object>()), 1f);
FallSpeedMultiplier = new SyncedConfigEntry<float>(configFile, "Extension Ladders", "FallSpeedMultiplier", 1f, new ConfigDescription("Multiplies how fast the ladder falls once fully extended (1 in vanilla)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 10f), Array.Empty<object>()), 1f);
FallDelay = new SyncedConfigEntry<float>(configFile, "Extension Ladders", "FallDelay", 0.4f, new ConfigDescription("How long before the ladder begins to fall once fully extended, in seconds (0.4 in vanilla)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 15f), Array.Empty<object>()), 0.4f);
EnableKillTrigger = new SyncedConfigEntry<bool>(configFile, "Extension Ladders", "EnableKillTrigger", defaultValue: true, "Whether extension ladders should kill players they land on (true in vanilla)", vanillaValue: true);
HoldToPickup = new LocalConfigEntry<bool>(configFile, "Extension Ladders", "HoldToPickup", defaultValue: true, "Whether the interact key needs to be held to pick up an activated extension ladder");
HoldTime = new LocalConfigEntry<float>(configFile, "Extension Ladders", "HoldTime", 0.5f, new ConfigDescription("How long the interact key must be held if holdToPickup is true, in seconds", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 15f), Array.Empty<object>()));
DebugMode = new LocalConfigEntry<bool>(configFile, "Debug", "DebugMode", defaultValue: false, "Displays debug messages in the BepInEx console if true");
ClearOrphanedEntries(configFile);
configFile.Save();
configFile.SaveOnConfigSet = true;
}
private static void ClearOrphanedEntries(ConfigFile configFile)
{
((Dictionary<ConfigDefinition, string>)AccessTools.Property(typeof(ConfigFile), "OrphanedEntries").GetValue(configFile)).Clear();
}
}
public class LocalConfigEntry<T> : CustomConfigEntry<T>
{
public override T Value => ConfigEntry.Value;
public LocalConfigEntry(ConfigFile configFile, string section, string key, T defaultValue, ConfigDescription configDescription)
: base(configFile, section, key, defaultValue, configDescription)
{
Init();
}
public LocalConfigEntry(ConfigFile configFile, string section, string key, T defaultValue, string configDescription)
: this(configFile, section, key, defaultValue, new ConfigDescription(configDescription, (AcceptableValueBase)null, Array.Empty<object>()))
{
}//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Expected O, but got Unknown
protected override void LethalConfigCompat()
{
LethalConfig.AddConfigEntry<T>(ConfigEntry);
}
}
public class SyncedConfig : NetworkBehaviour
{
internal readonly NetworkVariable<float> ClimbSpeedMultiplier = new NetworkVariable<float>(0f, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);
internal readonly NetworkVariable<float> SprintingClimbSpeedMultiplier = new NetworkVariable<float>(0f, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);
internal readonly NetworkVariable<float> TransitionSpeedMultiplier = new NetworkVariable<float>(0f, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);
internal readonly NetworkVariable<bool> AllowTwoHanded = new NetworkVariable<bool>(false, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);
internal readonly NetworkVariable<float> ExtensionTime = new NetworkVariable<float>(0f, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);
internal readonly NetworkVariable<float> ExtensionSpeedMultiplier = new NetworkVariable<float>(0f, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);
internal readonly NetworkVariable<float> ExtensionDelay = new NetworkVariable<float>(0f, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);
internal readonly NetworkVariable<float> FallSpeedMultiplier = new NetworkVariable<float>(0f, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);
internal readonly NetworkVariable<float> FallDelay = new NetworkVariable<float>(0f, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);
internal readonly NetworkVariable<bool> EnableKillTrigger = new NetworkVariable<bool>(false, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);
internal NetworkVariableBase[] NetworkVariables;
public static SyncedConfig Instance { get; private set; }
internal static event Action OnInitialized;
internal static void Initialize(Scene sceneName, LoadSceneMode sceneEnum)
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Expected O, but got Unknown
if (!(((Scene)(ref sceneName)).name != "SampleSceneRelay"))
{
GameObject val = new GameObject("BetterLaddersSyncedConfig");
val.AddComponent<NetworkObject>();
Instance = val.AddComponent<SyncedConfig>();
BetterLaddersPlugin.Logger.LogInfo((object)("Initialized " + ((Object)val).name));
}
}
public override void OnNetworkSpawn()
{
BetterLaddersPlugin.Logger.LogInfo((object)"SyncedConfig network spawned");
SyncedConfig.OnInitialized?.Invoke();
Action onInitialized = SyncedConfig.OnInitialized;
if (onInitialized != null)
{
ArrayHelpers.Clear<Delegate>(onInitialized.GetInvocationList());
}
BetterLaddersPlugin.Logger.LogInfo((object)"Finished initializing NetworkVariables");
}
[Rpc(/*Could not decode attribute arguments.*/)]
public void RequestChangeItemVisibilityRpc(NetworkBehaviourReference itemReference, bool visible)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
//IL_00cc: Invalid comparison between Unknown and I4
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//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)
{
RpcAttributeParams val = default(RpcAttributeParams);
RpcParams val2 = default(RpcParams);
FastBufferWriter val3 = ((NetworkBehaviour)this).__beginSendRpc(3987140488u, val2, val, (SendTo)5, (RpcDelivery)0);
((FastBufferWriter)(ref val3)).WriteValueSafe<NetworkBehaviourReference>(ref itemReference, default(ForNetworkSerializable));
((FastBufferWriter)(ref val3)).WriteValueSafe<bool>(ref visible, default(ForPrimitives));
((NetworkBehaviour)this).__endSendRpc(ref val3, 3987140488u, val2, val, (SendTo)5, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage != 1)
{
return;
}
base.__rpc_exec_stage = (__RpcExecStage)0;
GrabbableObject val4 = default(GrabbableObject);
if (!((NetworkBehaviourReference)(ref itemReference)).TryGet<GrabbableObject>(ref val4, (NetworkManager)null))
{
BetterLaddersPlugin.Logger.LogWarning((object)"Failed to get item from reference while hiding item");
return;
}
PlayerControllerB playerHeldBy = val4.playerHeldBy;
if (!((Object)(object)playerHeldBy == (Object)null) && ((LocalConfig.Instance.HideOneHanded.Value && !playerHeldBy.twoHanded) || (LocalConfig.Instance.HideTwoHanded.Value && playerHeldBy.twoHanded)))
{
BetterLaddersPlugin.Logger.LogInfo((object)("Hiding item visibility for " + playerHeldBy.playerUsername));
val4.EnableItemMeshes(visible);
}
}
[Rpc(/*Could not decode attribute arguments.*/)]
public void RequestStartChangeAnimationSpeedRpc(NetworkBehaviourReference playerReference)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Invalid comparison between Unknown and I4
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
//IL_00c0: 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)
{
RpcAttributeParams val = default(RpcAttributeParams);
RpcParams val2 = default(RpcParams);
FastBufferWriter val3 = ((NetworkBehaviour)this).__beginSendRpc(1239607073u, val2, val, (SendTo)5, (RpcDelivery)0);
((FastBufferWriter)(ref val3)).WriteValueSafe<NetworkBehaviourReference>(ref playerReference, default(ForNetworkSerializable));
((NetworkBehaviour)this).__endSendRpc(ref val3, 1239607073u, val2, val, (SendTo)5, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage == 1)
{
base.__rpc_exec_stage = (__RpcExecStage)0;
PlayerControllerB val4 = default(PlayerControllerB);
if (!((NetworkBehaviourReference)(ref playerReference)).TryGet<PlayerControllerB>(ref val4, (NetworkManager)null))
{
BetterLaddersPlugin.Logger.LogWarning((object)"Failed to get player from reference while starting animation speed coroutine");
}
else
{
((MonoBehaviour)val4).StartCoroutine(ClimbSpeed.SetAnimationSpeed(val4));
}
}
}
private void Awake()
{
NetworkVariables = (NetworkVariableBase[])(object)new NetworkVariableBase[10]
{
(NetworkVariableBase)ClimbSpeedMultiplier,
(NetworkVariableBase)SprintingClimbSpeedMultiplier,
(NetworkVariableBase)TransitionSpeedMultiplier,
(NetworkVariableBase)AllowTwoHanded,
(NetworkVariableBase)ExtensionTime,
(NetworkVariableBase)ExtensionSpeedMultiplier,
(NetworkVariableBase)ExtensionDelay,
(NetworkVariableBase)FallSpeedMultiplier,
(NetworkVariableBase)FallDelay,
(NetworkVariableBase)EnableKillTrigger
};
}
protected override void __initializeVariables()
{
if (ClimbSpeedMultiplier == null)
{
throw new Exception("SyncedConfig.ClimbSpeedMultiplier cannot be null. All NetworkVariableBase instances must be initialized.");
}
((NetworkVariableBase)ClimbSpeedMultiplier).Initialize((NetworkBehaviour)(object)this);
((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)ClimbSpeedMultiplier, "ClimbSpeedMultiplier");
base.NetworkVariableFields.Add((NetworkVariableBase)(object)ClimbSpeedMultiplier);
if (SprintingClimbSpeedMultiplier == null)
{
throw new Exception("SyncedConfig.SprintingClimbSpeedMultiplier cannot be null. All NetworkVariableBase instances must be initialized.");
}
((NetworkVariableBase)SprintingClimbSpeedMultiplier).Initialize((NetworkBehaviour)(object)this);
((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)SprintingClimbSpeedMultiplier, "SprintingClimbSpeedMultiplier");
base.NetworkVariableFields.Add((NetworkVariableBase)(object)SprintingClimbSpeedMultiplier);
if (TransitionSpeedMultiplier == null)
{
throw new Exception("SyncedConfig.TransitionSpeedMultiplier cannot be null. All NetworkVariableBase instances must be initialized.");
}
((NetworkVariableBase)TransitionSpeedMultiplier).Initialize((NetworkBehaviour)(object)this);
((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)TransitionSpeedMultiplier, "TransitionSpeedMultiplier");
base.NetworkVariableFields.Add((NetworkVariableBase)(object)TransitionSpeedMultiplier);
if (AllowTwoHanded == null)
{
throw new Exception("SyncedConfig.AllowTwoHanded cannot be null. All NetworkVariableBase instances must be initialized.");
}
((NetworkVariableBase)AllowTwoHanded).Initialize((NetworkBehaviour)(object)this);
((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)AllowTwoHanded, "AllowTwoHanded");
base.NetworkVariableFields.Add((NetworkVariableBase)(object)AllowTwoHanded);
if (ExtensionTime == null)
{
throw new Exception("SyncedConfig.ExtensionTime cannot be null. All NetworkVariableBase instances must be initialized.");
}
((NetworkVariableBase)ExtensionTime).Initialize((NetworkBehaviour)(object)this);
((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)ExtensionTime, "ExtensionTime");
base.NetworkVariableFields.Add((NetworkVariableBase)(object)ExtensionTime);
if (ExtensionSpeedMultiplier == null)
{
throw new Exception("SyncedConfig.ExtensionSpeedMultiplier cannot be null. All NetworkVariableBase instances must be initialized.");
}
((NetworkVariableBase)ExtensionSpeedMultiplier).Initialize((NetworkBehaviour)(object)this);
((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)ExtensionSpeedMultiplier, "ExtensionSpeedMultiplier");
base.NetworkVariableFields.Add((NetworkVariableBase)(object)ExtensionSpeedMultiplier);
if (ExtensionDelay == null)
{
throw new Exception("SyncedConfig.ExtensionDelay cannot be null. All NetworkVariableBase instances must be initialized.");
}
((NetworkVariableBase)ExtensionDelay).Initialize((NetworkBehaviour)(object)this);
((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)ExtensionDelay, "ExtensionDelay");
base.NetworkVariableFields.Add((NetworkVariableBase)(object)ExtensionDelay);
if (FallSpeedMultiplier == null)
{
throw new Exception("SyncedConfig.FallSpeedMultiplier cannot be null. All NetworkVariableBase instances must be initialized.");
}
((NetworkVariableBase)FallSpeedMultiplier).Initialize((NetworkBehaviour)(object)this);
((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)FallSpeedMultiplier, "FallSpeedMultiplier");
base.NetworkVariableFields.Add((NetworkVariableBase)(object)FallSpeedMultiplier);
if (FallDelay == null)
{
throw new Exception("SyncedConfig.FallDelay cannot be null. All NetworkVariableBase instances must be initialized.");
}
((NetworkVariableBase)FallDelay).Initialize((NetworkBehaviour)(object)this);
((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)FallDelay, "FallDelay");
base.NetworkVariableFields.Add((NetworkVariableBase)(object)FallDelay);
if (EnableKillTrigger == null)
{
throw new Exception("SyncedConfig.EnableKillTrigger cannot be null. All NetworkVariableBase instances must be initialized.");
}
((NetworkVariableBase)EnableKillTrigger).Initialize((NetworkBehaviour)(object)this);
((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)EnableKillTrigger, "EnableKillTrigger");
base.NetworkVariableFields.Add((NetworkVariableBase)(object)EnableKillTrigger);
((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
((NetworkBehaviour)this).__registerRpc(3987140488u, new RpcReceiveHandler(__rpc_handler_3987140488), "RequestChangeItemVisibilityRpc");
((NetworkBehaviour)this).__registerRpc(1239607073u, new RpcReceiveHandler(__rpc_handler_1239607073), "RequestStartChangeAnimationSpeedRpc");
((NetworkBehaviour)this).__initializeRpcs();
}
private static void __rpc_handler_3987140488(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
NetworkBehaviourReference itemReference = default(NetworkBehaviourReference);
((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref itemReference, default(ForNetworkSerializable));
bool visible = default(bool);
((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref visible, default(ForPrimitives));
target.__rpc_exec_stage = (__RpcExecStage)1;
((SyncedConfig)(object)target).RequestChangeItemVisibilityRpc(itemReference, visible);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
private static void __rpc_handler_1239607073(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: 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_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)
{
NetworkBehaviourReference playerReference = default(NetworkBehaviourReference);
((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref playerReference, default(ForNetworkSerializable));
target.__rpc_exec_stage = (__RpcExecStage)1;
((SyncedConfig)(object)target).RequestStartChangeAnimationSpeedRpc(playerReference);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
[MethodImpl(MethodImplOptions.NoInlining)]
protected internal override string __getTypeName()
{
return "SyncedConfig";
}
}
internal static class Counter
{
public static int Count;
}
public class SyncedConfigEntry<T> : CustomConfigEntry<T>
{
public readonly T VanillaValue;
private readonly int _id;
private static bool IsHost
{
get
{
if (!NetworkManager.Singleton.IsHost)
{
return NetworkManager.Singleton.IsServer;
}
return true;
}
}
private static bool InMainMenu
{
get
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
Scene activeScene = SceneManager.GetActiveScene();
return ((Scene)(ref activeScene)).name == "MainMenu";
}
}
private string ConfigName => ((ConfigEntryBase)ConfigEntry).Definition.Key;
private NetworkVariable<T> NetworkVariable => (NetworkVariable<T>)(object)SyncedConfig.Instance.NetworkVariables[_id];
public override T Value
{
get
{
if (!IsHost && !((NetworkBehaviour)SyncedConfig.Instance).IsSpawned)
{
return VanillaValue;
}
return NetworkVariable.Value;
}
}
public SyncedConfigEntry(ConfigFile configFile, string section, string key, T defaultValue, ConfigDescription configDescription, T vanillaValue)
: base(configFile, section + " (Synced)", key, defaultValue, configDescription)
{
Init();
_id = Counter.Count++;
VanillaValue = vanillaValue;
ConfigEntry.SettingChanged += OnSettingChanged;
SyncedConfig.OnInitialized += delegate
{
if (IsHost)
{
BetterLaddersPlugin.Logger.LogInfo((object)$"[HOST] Setting initial value for {ConfigName} NetworkVariable to {ConfigEntry.Value}");
NetworkVariable.Value = ConfigEntry.Value;
}
else
{
NetworkVariable<T> networkVariable = NetworkVariable;
networkVariable.OnValueChanged = (OnValueChangedDelegate<T>)(object)Delegate.Combine((Delegate?)(object)networkVariable.OnValueChanged, (Delegate?)(object)(OnValueChangedDelegate<T>)delegate(T oldValue, T newValue)
{
BetterLaddersPlugin.Logger.LogInfo((object)$"[CLIENT] Host changed NetworkVariable for {ConfigName} to {newValue}");
});
}
};
}
public SyncedConfigEntry(ConfigFile configFile, string section, string key, T defaultValue, string configDescription, T vanillaValue)
: this(configFile, section, key, defaultValue, new ConfigDescription(configDescription, (AcceptableValueBase)null, Array.Empty<object>()), vanillaValue)
{
}//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Expected O, but got Unknown
private void OnSettingChanged(object sender, EventArgs args)
{
T value = ConfigEntry.Value;
if (NetworkManager.Singleton.IsHost && ((NetworkBehaviour)SyncedConfig.Instance).IsSpawned)
{
BetterLaddersPlugin.Logger.LogInfo((object)$"[HOST] Changed {ConfigName} to {value}, updating NetworkVariable...");
NetworkVariable.Value = value;
}
}
private (bool, string) CanModifyCallback()
{
if (IsHost || InMainMenu)
{
return (true, "");
}
if (!IsHost && !((NetworkBehaviour)SyncedConfig.Instance).IsSpawned && !InMainMenu)
{
return (false, $"Host is missing BetterLadders; using vanilla value of {VanillaValue}");
}
string text = ((typeof(T) == typeof(float)) ? ((float)(object)Value).ToString("0.00") : Value.ToString());
return (false, "Using host's value of " + text);
}
protected override void LethalConfigCompat()
{
LethalConfig.AddConfigEntry<T>(ConfigEntry, CanModifyCallback);
}
}
}
namespace BetterLadders.Compatibility
{
internal static class LethalConfig
{
internal static bool IsInstalled { get; private set; }
internal static void Init()
{
IsInstalled = true;
}
internal static void AddConfigEntry<T>(ConfigEntry<T> configEntry, Func<(bool allowed, string reason)> canModifyCallback = null)
{
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Expected O, but got Unknown
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Expected O, but got Unknown
BetterLaddersPlugin.Logger.LogInfo((object)("Setting up LethalConfig entry for " + ((ConfigEntryBase)configEntry).Definition.Key));
LethalConfigManager.SkipAutoGenFor((ConfigEntryBase)(object)configEntry);
Type typeFromHandle = typeof(T);
BaseConfigItem val;
if (typeFromHandle == typeof(float))
{
val = (BaseConfigItem)new FloatSliderConfigItem(configEntry as ConfigEntry<float>, Options<FloatSliderOptions>());
}
else
{
if (!(typeFromHandle == typeof(bool)))
{
throw new NotImplementedException($"{typeof(T)} not implemented for Compatibility.LethalConfig.SetupConfigEntry<T>");
}
val = (BaseConfigItem)new BoolCheckBoxConfigItem(configEntry as ConfigEntry<bool>, Options<BoolCheckBoxOptions>());
}
LethalConfigManager.AddConfigItem(val);
TOptions Options<TOptions>() where TOptions : BaseOptions, new()
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
object obj = new TOptions();
((BaseOptions)(TOptions)obj).RequiresRestart = false;
obj = (((BaseOptions)(TOptions)obj).CanModifyCallback = ((canModifyCallback == null) ? ((CanModifyDelegate)null) : ((CanModifyDelegate)(() => CanModifyResult.op_Implicit(canModifyCallback())))));
return (TOptions)obj;
}
}
}
internal static class LobbyCompatibility
{
internal static void Init(BepInPlugin info)
{
PluginHelper.RegisterPlugin(info.GUID, info.Version, (CompatibilityLevel)0, (VersionStrictness)2);
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
int ICollection.Count => _items.Length;
bool ICollection.IsSynchronized => false;
object ICollection.SyncRoot => this;
object IList.this[int index]
{
get
{
return _items[index];
}
set
{
throw new NotSupportedException();
}
}
bool IList.IsFixedSize => true;
bool IList.IsReadOnly => true;
int IReadOnlyCollection<T>.Count => _items.Length;
T IReadOnlyList<T>.this[int index] => _items[index];
int ICollection<T>.Count => _items.Length;
bool ICollection<T>.IsReadOnly => true;
T IList<T>.this[int index]
{
get
{
return _items[index];
}
set
{
throw new NotSupportedException();
}
}
public <>z__ReadOnlyArray(T[] items)
{
_items = items;
}
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable)_items).GetEnumerator();
}
void ICollection.CopyTo(Array array, int index)
{
((ICollection)_items).CopyTo(array, index);
}
int IList.Add(object value)
{
throw new NotSupportedException();
}
void IList.Clear()
{
throw new NotSupportedException();
}
bool IList.Contains(object value)
{
return ((IList)_items).Contains(value);
}
int IList.IndexOf(object value)
{
return ((IList)_items).IndexOf(value);
}
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 ((IEnumerable<T>)_items).GetEnumerator();
}
void ICollection<T>.Add(T item)
{
throw new NotSupportedException();
}
void ICollection<T>.Clear()
{
throw new NotSupportedException();
}
bool ICollection<T>.Contains(T item)
{
return ((ICollection<T>)_items).Contains(item);
}
void ICollection<T>.CopyTo(T[] array, int arrayIndex)
{
((ICollection<T>)_items).CopyTo(array, arrayIndex);
}
bool ICollection<T>.Remove(T item)
{
throw new NotSupportedException();
}
int IList<T>.IndexOf(T item)
{
return ((IList<T>)_items).IndexOf(item);
}
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()
{
NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpy<float>();
NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatable<float>();
NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpy<bool>();
NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatable<bool>();
}
}
}
namespace e3s1.BetterLadders.NetcodePatcher
{
[AttributeUsage(AttributeTargets.Module)]
internal class NetcodePatchedAssemblyAttribute : Attribute
{
}
}
