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.InteropServices;
using System.Runtime.Versioning;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.NET.Common;
using BepInExResoniteShim;
using Elements.Core;
using FrooxEngine;
using HarmonyLib;
using Renderite.Shared;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(/*Could not decode attribute arguments.*/)]
[assembly: TargetFramework(".NETCoreApp,Version=v10.0", FrameworkDisplayName = ".NET 10.0")]
[assembly: AssemblyCompany("art0007i")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.6.0")]
[assembly: AssemblyInformationalVersion("1.0.6+4ed676e363837bc3774ccae84dd6ce9a61c162e6")]
[assembly: AssemblyProduct("DefaultToolOverride")]
[assembly: AssemblyTitle("DefaultToolOverride")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/art0007i/DefaultToolOverride")]
[assembly: AssemblyVersion("1.0.6.0")]
[module: RefSafetyRules(11)]
namespace DefaultToolOverride;
[ResonitePlugin("art0007i.DefaultToolOverride", "DefaultToolOverride", "1.0.6", "art0007i", "https://github.com/art0007i/DefaultToolOverride")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class Plugin : BasePlugin
{
public enum OverrideType
{
Fallback,
None,
Dequip,
URL,
ClassName
}
public enum ModifierKey
{
None,
Shift,
Alt,
Control,
Any
}
public struct ToolReplacement
{
[CompilerGenerated]
private global::System.Type <ToolType>k__BackingField;
public OverrideType Type => <type>P.Value;
public string Str => <str>P.Value;
public global::System.Type ToolType
{
get
{
string str = Str;
if (<ToolType>k__BackingField == (global::System.Type)null || !str.Contains(((MemberInfo)<ToolType>k__BackingField).Name))
{
<ToolType>k__BackingField = TypeHelper.FindType(str);
}
return <ToolType>k__BackingField;
}
}
public ToolReplacement(ConfigEntry<OverrideType> type, ConfigEntry<string> str)
{
<type>P = type;
<str>P = str;
<ToolType>k__BackingField = null;
}
}
[HarmonyPatch(typeof(InteractionHandler), "OnInputUpdate")]
private class DefaultToolOverridePatch
{
[CompilerGenerated]
private sealed class <>c__DisplayClass0_0
{
[StructLayout((LayoutKind)3)]
private struct <<ToolIntercept>b__0>d : IAsyncStateMachine
{
public int <>1__state;
public AsyncTaskMethodBuilder <>t__builder;
public <>c__DisplayClass0_0 <>4__this;
private TaskAwaiter <>u__1;
private void MoveNext()
{
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
int num = <>1__state;
<>c__DisplayClass0_0 <>c__DisplayClass0_ = <>4__this;
try
{
TaskAwaiter val;
if (num != 0)
{
val = <>c__DisplayClass0_.instance.SpawnAndEquip(<>c__DisplayClass0_.uri).GetAwaiter();
if (!((TaskAwaiter)(ref val)).IsCompleted)
{
num = (<>1__state = 0);
<>u__1 = val;
((AsyncTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<TaskAwaiter, <<ToolIntercept>b__0>d>(ref val, ref this);
return;
}
}
else
{
val = <>u__1;
<>u__1 = default(TaskAwaiter);
num = (<>1__state = -1);
}
((TaskAwaiter)(ref val)).GetResult();
}
catch (global::System.Exception exception)
{
<>1__state = -2;
((AsyncTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
return;
}
<>1__state = -2;
((AsyncTaskMethodBuilder)(ref <>t__builder)).SetResult();
}
[DebuggerHidden]
private void SetStateMachine(IAsyncStateMachine stateMachine)
{
((AsyncTaskMethodBuilder)(ref <>t__builder)).SetStateMachine(stateMachine);
}
}
public InteractionHandler instance;
public Uri uri;
[AsyncStateMachine(typeof(<<ToolIntercept>b__0>d))]
internal global::System.Threading.Tasks.Task <ToolIntercept>b__0()
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
<<ToolIntercept>b__0>d <<ToolIntercept>b__0>d = default(<<ToolIntercept>b__0>d);
<<ToolIntercept>b__0>d.<>t__builder = AsyncTaskMethodBuilder.Create();
<<ToolIntercept>b__0>d.<>4__this = this;
<<ToolIntercept>b__0>d.<>1__state = -1;
((AsyncTaskMethodBuilder)(ref <<ToolIntercept>b__0>d.<>t__builder)).Start<<<ToolIntercept>b__0>d>(ref <<ToolIntercept>b__0>d);
return ((AsyncTaskMethodBuilder)(ref <<ToolIntercept>b__0>d.<>t__builder)).Task;
}
}
[CompilerGenerated]
private sealed class <Transpiler>d__1 : global::System.Collections.Generic.IEnumerable<CodeInstruction>, global::System.Collections.IEnumerable, global::System.Collections.Generic.IEnumerator<CodeInstruction>, global::System.Collections.IEnumerator, global::System.IDisposable
{
private int <>1__state;
private CodeInstruction <>2__current;
private int <>l__initialThreadId;
private MethodBase method;
public MethodBase <>3__method;
private global::System.Collections.Generic.IEnumerable<CodeInstruction> codes;
public global::System.Collections.Generic.IEnumerable<CodeInstruction> <>3__codes;
private int <localIndex>5__2;
private Label <lastLabel>5__3;
private global::System.Collections.Generic.IEnumerator<CodeInstruction> <>7__wrap3;
private CodeInstruction <code>5__5;
CodeInstruction global::System.Collections.Generic.IEnumerator<CodeInstruction>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object global::System.Collections.IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <Transpiler>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
<>l__initialThreadId = Environment.CurrentManagedThreadId;
}
[DebuggerHidden]
void global::System.IDisposable.Dispose()
{
int num = <>1__state;
if (num == -3 || (uint)(num - 1) <= 4u)
{
try
{
}
finally
{
<>m__Finally1();
}
}
<>7__wrap3 = null;
<code>5__5 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0167: Unknown result type (might be due to invalid IL or missing references)
//IL_0180: Unknown result type (might be due to invalid IL or missing references)
//IL_018a: Expected O, but got Unknown
//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
//IL_01a7: 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_01bb: Expected O, but got Unknown
//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
//IL_01ed: Expected O, but got Unknown
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Expected O, but got Unknown
//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
//IL_0108: Unknown result type (might be due to invalid IL or missing references)
//IL_010d: Unknown result type (might be due to invalid IL or missing references)
//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
//IL_0140: Unknown result type (might be due to invalid IL or missing references)
//IL_0146: Unknown result type (might be due to invalid IL or missing references)
//IL_0150: Expected O, but got Unknown
try
{
switch (<>1__state)
{
default:
return false;
case 0:
{
<>1__state = -1;
<localIndex>5__2 = Enumerable.Last<LocalVariableInfo>((global::System.Collections.Generic.IEnumerable<LocalVariableInfo>)method.GetMethodBody().LocalVariables, (Func<LocalVariableInfo, bool>)((LocalVariableInfo x) => x.LocalType == typeof(int))).LocalIndex;
ManualLogSource log = Log;
bool flag = default(bool);
BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(21, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Found local at index ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(<localIndex>5__2);
}
log.LogDebug(val);
<lastLabel>5__3 = default(Label);
<>7__wrap3 = codes.GetEnumerator();
<>1__state = -3;
goto IL_0226;
}
case 1:
<>1__state = -3;
<>2__current = new CodeInstruction(OpCodes.Call, (object)typeof(DefaultToolOverridePatch).GetMethod("ToolIntercept"));
<>1__state = 2;
return true;
case 2:
<>1__state = -3;
<>2__current = new CodeInstruction(OpCodes.Brfalse, (object)<lastLabel>5__3);
<>1__state = 3;
return true;
case 3:
<>1__state = -3;
<>2__current = new CodeInstruction(OpCodes.Ldloc_S, (object)(byte)<localIndex>5__2);
<>1__state = 4;
return true;
case 4:
<>1__state = -3;
goto IL_0200;
case 5:
{
<>1__state = -3;
<code>5__5 = null;
goto IL_0226;
}
IL_0226:
if (((global::System.Collections.IEnumerator)<>7__wrap3).MoveNext())
{
<code>5__5 = <>7__wrap3.Current;
Label? val2 = default(Label?);
if (CodeInstructionExtensions.Branches(<code>5__5, ref val2) && val2.HasValue)
{
<lastLabel>5__3 = val2.Value;
}
if (<code>5__5.opcode == OpCodes.Switch && <code>5__5.operand is Label[] array && array.Length > 6)
{
<>2__current = new CodeInstruction(OpCodes.Ldarg_0, (object)null);
<>1__state = 1;
return true;
}
goto IL_0200;
}
<>m__Finally1();
<>7__wrap3 = null;
return false;
IL_0200:
<>2__current = <code>5__5;
<>1__state = 5;
return true;
}
}
catch
{
//try-fault
((global::System.IDisposable)this).Dispose();
throw;
}
}
bool global::System.Collections.IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
<>1__state = -1;
if (<>7__wrap3 != null)
{
((global::System.IDisposable)<>7__wrap3).Dispose();
}
}
[DebuggerHidden]
void global::System.Collections.IEnumerator.Reset()
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
throw new NotSupportedException();
}
[DebuggerHidden]
global::System.Collections.Generic.IEnumerator<CodeInstruction> global::System.Collections.Generic.IEnumerable<CodeInstruction>.GetEnumerator()
{
<Transpiler>d__1 <Transpiler>d__;
if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
{
<>1__state = 0;
<Transpiler>d__ = this;
}
else
{
<Transpiler>d__ = new <Transpiler>d__1(0);
}
<Transpiler>d__.codes = <>3__codes;
<Transpiler>d__.method = <>3__method;
return <Transpiler>d__;
}
[DebuggerHidden]
global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
{
return (global::System.Collections.IEnumerator)((global::System.Collections.Generic.IEnumerable<CodeInstruction>)this).GetEnumerator();
}
}
public static bool ToolIntercept(int toolNum, InteractionHandler instance)
{
//IL_0153: Unknown result type (might be due to invalid IL or missing references)
//IL_015a: Expected O, but got Unknown
//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
//IL_01fd: Expected O, but got Unknown
//IL_01de: Unknown result type (might be due to invalid IL or missing references)
//IL_01ea: Expected O, but got Unknown
<>c__DisplayClass0_0 CS$<>8__locals9 = new <>c__DisplayClass0_0();
CS$<>8__locals9.instance = instance;
bool flag = true;
InputInterface inputInterface = ((Worker)CS$<>8__locals9.instance).InputInterface;
Key[] array = new Key[3];
RuntimeHelpers.InitializeArray((global::System.Array)array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
bool anyKey = inputInterface.GetAnyKey((Key[])(object)array);
InputInterface inputInterface2 = ((Worker)CS$<>8__locals9.instance).InputInterface;
Key[] array2 = new Key[3];
RuntimeHelpers.InitializeArray((global::System.Array)array2, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
bool anyKey2 = inputInterface2.GetAnyKey((Key[])(object)array2);
InputInterface inputInterface3 = ((Worker)CS$<>8__locals9.instance).InputInterface;
Key[] array3 = new Key[3];
RuntimeHelpers.InitializeArray((global::System.Array)array3, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
bool anyKey3 = inputInterface3.GetAnyKey((Key[])(object)array3);
switch (Modifier.Value)
{
case ModifierKey.Shift:
if (!anyKey)
{
flag = false;
}
break;
case ModifierKey.Alt:
if (!anyKey2)
{
flag = false;
}
break;
case ModifierKey.Control:
if (!anyKey3)
{
flag = false;
}
break;
case ModifierKey.Any:
if (!(anyKey || anyKey2 || anyKey3))
{
flag = false;
}
break;
}
if (flag == InvertModifier.Value)
{
return false;
}
ToolReplacement toolReplacement = default(ToolReplacement);
if (ConfigKeys.TryGetValue(toolNum, ref toolReplacement))
{
bool flag2 = default(bool);
switch (toolReplacement.Type)
{
case OverrideType.Fallback:
return true;
case OverrideType.None:
return false;
case OverrideType.Dequip:
CS$<>8__locals9.instance.StashCurrentToolOrDequip();
return false;
case OverrideType.URL:
{
if (Uri.TryCreate(toolReplacement.Str, (UriKind)1, ref CS$<>8__locals9.uri))
{
((Worker)CS$<>8__locals9.instance).StartTask((Func<global::System.Threading.Tasks.Task>)([AsyncStateMachine(typeof(<>c__DisplayClass0_0.<<ToolIntercept>b__0>d))] () =>
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
<>c__DisplayClass0_0.<<ToolIntercept>b__0>d <<ToolIntercept>b__0>d = default(<>c__DisplayClass0_0.<<ToolIntercept>b__0>d);
<<ToolIntercept>b__0>d.<>t__builder = AsyncTaskMethodBuilder.Create();
<<ToolIntercept>b__0>d.<>4__this = CS$<>8__locals9;
<<ToolIntercept>b__0>d.<>1__state = -1;
((AsyncTaskMethodBuilder)(ref <<ToolIntercept>b__0>d.<>t__builder)).Start<<>c__DisplayClass0_0.<<ToolIntercept>b__0>d>(ref <<ToolIntercept>b__0>d);
return ((AsyncTaskMethodBuilder)(ref <<ToolIntercept>b__0>d.<>t__builder)).Task;
}));
return false;
}
ManualLogSource log2 = Log;
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(29, 2, ref flag2);
if (flag2)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Invalid tool url '");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(toolReplacement.Str);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("' on tool ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(toolNum);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".");
}
log2.LogWarning(val);
return true;
}
case OverrideType.ClassName:
{
global::System.Type toolType = toolReplacement.ToolType;
if (toolType != (global::System.Type)null && typeof(ITool).IsAssignableFrom(toolType))
{
SpawnEquipFunc(CS$<>8__locals9.instance, new Uri("tool://tool" + toolNum), toolType);
return false;
}
ManualLogSource log = Log;
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(34, 2, ref flag2);
if (flag2)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Invalid tool TypeName '");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(toolReplacement.Str);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("' on tool ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(toolNum);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".");
}
log.LogWarning(val);
return true;
}
}
}
return true;
}
[IteratorStateMachine(typeof(<Transpiler>d__1))]
public static global::System.Collections.Generic.IEnumerable<CodeInstruction> Transpiler(global::System.Collections.Generic.IEnumerable<CodeInstruction> codes, MethodBase method)
{
int localIndex = Enumerable.Last<LocalVariableInfo>((global::System.Collections.Generic.IEnumerable<LocalVariableInfo>)method.GetMethodBody().LocalVariables, (Func<LocalVariableInfo, bool>)((LocalVariableInfo x) => x.LocalType == typeof(int))).LocalIndex;
ManualLogSource log = Log;
bool flag = default(bool);
BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(21, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Found local at index ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(localIndex);
}
log.LogDebug(val);
Label lastLabel = default(Label);
global::System.Collections.Generic.IEnumerator<CodeInstruction> enumerator = codes.GetEnumerator();
try
{
Label? val2 = default(Label?);
while (((global::System.Collections.IEnumerator)enumerator).MoveNext())
{
CodeInstruction code = enumerator.Current;
if (CodeInstructionExtensions.Branches(code, ref val2) && val2.HasValue)
{
lastLabel = val2.Value;
}
if (code.opcode == OpCodes.Switch && code.operand is Label[] array && array.Length > 6)
{
yield return new CodeInstruction(OpCodes.Ldarg_0, (object)null);
yield return new CodeInstruction(OpCodes.Call, (object)typeof(DefaultToolOverridePatch).GetMethod("ToolIntercept"));
yield return new CodeInstruction(OpCodes.Brfalse, (object)lastLabel);
yield return new CodeInstruction(OpCodes.Ldloc_S, (object)(byte)localIndex);
}
yield return code;
}
}
finally
{
((global::System.IDisposable)enumerator)?.Dispose();
}
}
public static void SpawnEquipFunc(InteractionHandler instance, Uri uri, global::System.Type toolType)
{
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
Traverse val = Traverse.Create((object)instance);
Traverse<Uri> val2 = val.Field<Uri>("_currentToolUri");
if (val2.Value == uri)
{
return;
}
Slot val3 = null;
bool flag = false;
try
{
Dictionary<Uri, ITool> value = val.Field<Dictionary<Uri, ITool>>("_stashedTools").Value;
ITool componentInChildren = default(ITool);
if (value.TryGetValue(uri, ref componentInChildren) && !((IWorldElement)componentInChildren).IsRemoved)
{
((IComponent)componentInChildren).Slot.ActiveSelf = true;
val3 = ((IComponent)componentInChildren).Slot;
}
else
{
val3 = ((Component)((Worker)instance).LocalUserRoot).Slot.AddSlot(((MemberInfo)toolType).Name, true);
((ContainerWorker<Component>)(object)val3).AttachComponent(toolType, true, (Action<Component>)null);
componentInChildren = val3.GetComponentInChildren<ITool>((Predicate<ITool>)null, false, false);
}
value.Remove(uri);
if (componentInChildren == null)
{
flag = true;
}
else if (!instance.CanEquip(componentInChildren))
{
flag = true;
NotificationMessage.SpawnTextMessage(((IComponent)componentInChildren).Slot, LocaleString.op_Implicit("You don't have permission to equip this."), colorX.Red, 3f, 0.15f, 0.5f, 0.1f, 0.2f, false);
}
else
{
instance.StashCurrentToolOrDequip();
instance.Equip(componentInChildren, true);
val2.Value = uri;
}
}
catch (global::System.Exception ex)
{
Log.LogError((object)("Exception trying to spawn and equip tooltip:\n" + (object)ex));
flag = true;
}
if (flag && val3 != null)
{
val3.Destroy();
}
}
}
internal static ManualLogSource Log;
public static ConfigEntry<bool> InvertModifier;
public static ConfigEntry<ModifierKey> Modifier;
public static Dictionary<int, ToolReplacement> ConfigKeys = new Dictionary<int, ToolReplacement>();
private void BuildToolKey(string name, int index)
{
ConfigEntry<OverrideType> type = ((BasePlugin)this).Config.Bind<OverrideType>("Tools", name + "_type", OverrideType.Fallback, "Tool " + name + " will use this mode.");
ConfigEntry<string> str = ((BasePlugin)this).Config.Bind<string>("Tools", name + "_string", "", "String for Tool " + name + ". (Only for URL / ClassName)");
ConfigKeys.Add(index, new ToolReplacement(type, str));
}
public override void Load()
{
Log = ((BasePlugin)this).Log;
InvertModifier = ((BasePlugin)this).Config.Bind<bool>("General", "InvertModifier", false, "Reverses the behavior of modifier key. (If you hold the modifier tools will not be spawned)");
Modifier = ((BasePlugin)this).Config.Bind<ModifierKey>("General", "Modifier", ModifierKey.None, "Tool spawning will require holding this modifier key.");
for (int i = 1; i < 10; i++)
{
BuildToolKey(i.ToString(), i);
}
BuildToolKey("0", 0);
BuildToolKey("minus", 10);
((BasePlugin)this).HarmonyInstance.PatchAll();
}
}
public static class PluginMetadata
{
public const string GUID = "art0007i.DefaultToolOverride";
public const string NAME = "DefaultToolOverride";
public const string VERSION = "1.0.6";
public const string AUTHORS = "art0007i";
public const string REPOSITORY_URL = "https://github.com/art0007i/DefaultToolOverride";
}
