using System;
using System.Collections.Generic;
using System.Diagnostics;
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 HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Utilities;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("darmuh")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.2.1.0")]
[assembly: AssemblyInformationalVersion("0.2.1+6071c8c8f03b156861fb9c8f8315f1b70c87965e")]
[assembly: AssemblyProduct("com.github.darmuh.AddControls")]
[assembly: AssemblyTitle("AddControls")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.2.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
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 BepInEx
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
internal sealed class BepInAutoPluginAttribute : Attribute
{
public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace BepInEx.Preloader.Core.Patching
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
internal sealed class PatcherAutoPluginAttribute : Attribute
{
public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace AddControls
{
public class BindManager
{
internal static List<BindManager> InputActionConfigs = new List<BindManager>();
public InputAction Action;
public int BindIndex;
public ConfigEntry<string> Setting;
public BindManager(InputAction action, int bindingIndex, ConfigEntry<string> config)
{
Action = action;
BindIndex = bindingIndex;
Setting = config;
InputActionConfigs.Add(this);
UpdateActionBinding();
}
public static bool TryGetFromConfig(ConfigEntry<string> config, out BindManager result)
{
ConfigEntry<string> config2 = config;
result = InputActionConfigs.FirstOrDefault((BindManager item) => item.Setting == config2);
return result != null;
}
public static bool IsThisExistingConfigItem(InputAction action, string value)
{
InputAction action2 = action;
string value2 = value;
return InputActionConfigs.Any((BindManager x) => x.Action == action2 && x.Setting.Value == value2);
}
public static void UpdateFromConfig(ConfigEntry<string> entry)
{
if (TryGetFromConfig(entry, out BindManager result))
{
result.UpdateActionBinding();
}
}
public void UpdateActionBinding()
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
BindingSyntax val = InputActionSetupExtensions.ChangeBinding(Action, BindIndex);
((BindingSyntax)(ref val)).WithPath(Setting.Value);
}
public static void CheckAll()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
foreach (BindManager inputActionConfig in InputActionConfigs)
{
string value = inputActionConfig.Setting.Value;
InputBinding val = inputActionConfig.Action.bindings[inputActionConfig.BindIndex];
if (value != ((InputBinding)(ref val)).effectivePath)
{
inputActionConfig.UpdateActionBinding();
}
}
}
}
public class ManualBind
{
internal static List<ManualBind> ManualBindings = new List<ManualBind>();
public InputAction Action;
public int AddedBindIndex;
public string Value;
public ManualBind(InputAction action, string value)
{
Action = action;
Value = value;
ManualBindings.Add(this);
AddBinding();
}
public void AddBinding()
{
//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_0035: Unknown result type (might be due to invalid IL or missing references)
if (!BindManager.IsThisExistingConfigItem(Action, Value))
{
InputActionSetupExtensions.AddBinding(Action, Value, (string)null, (string)null, (string)null);
AddedBindIndex = Action.bindings.IndexOf((Predicate<InputBinding>)((InputBinding b) => ((InputBinding)(ref b)).effectivePath.Equals(Value, StringComparison.InvariantCultureIgnoreCase)));
}
}
public void RemoveBinding()
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
BindingSyntax val = InputActionSetupExtensions.ChangeBinding(Action, AddedBindIndex);
((BindingSyntax)(ref val)).Erase();
}
public static void ClearAll()
{
for (int num = ManualBindings.Count - 1; num >= 0; num--)
{
ManualBindings[num].RemoveBinding();
}
ManualBindings.Clear();
}
}
[BepInPlugin("com.github.darmuh.AddControls", "AddControls", "0.2.1")]
public class Plugin : BaseUnityPlugin
{
internal static List<string> DeviceNames = new List<string>();
internal static List<string> ValidKeyPaths = new List<string>();
internal static ConfigEntry<string> BindsAdded = null;
public const string Id = "com.github.darmuh.AddControls";
internal static Plugin Instance { get; private set; } = null;
internal static ManualLogSource Log { get; private set; } = null;
public static string Name => "AddControls";
public static string Version => "0.2.1";
private void Start()
{
Instance = this;
Log = ((BaseUnityPlugin)this).Logger;
Log.LogInfo((object)("Plugin " + Name + " is loaded!\nConfiguration file is located at " + Paths.ConfigPath));
BindsAdded = ((BaseUnityPlugin)this).Config.Bind<string>("Manual Binds", "Binds Added", "", "List your custom additional binds here.\nFormat is ActionName:binding;ActionName2:binding2\nNOTE: Any change to this setting will remove and refresh all additive binds!\nNOTE2: Find valid action names and keypath bindings in the LogOutput.log file when enabling bepinex's debug logging");
ValidKeyPaths = GenerateValidKeyPaths();
Log.LogMessage((object)"Enable debug logging to see ALL valid ActionNames!");
CollectionExtensions.Do<InputAction>((IEnumerable<InputAction>)InputSystem.actions, (Action<InputAction>)delegate(InputAction a)
{
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_020e: Unknown result type (might be due to invalid IL or missing references)
//IL_0213: Unknown result type (might be due to invalid IL or missing references)
//IL_0217: Unknown result type (might be due to invalid IL or missing references)
//IL_021c: Unknown result type (might be due to invalid IL or missing references)
//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
//IL_0236: Unknown result type (might be due to invalid IL or missing references)
//IL_023b: Unknown result type (might be due to invalid IL or missing references)
//IL_023f: Unknown result type (might be due to invalid IL or missing references)
//IL_0244: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: 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_009f: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
//IL_02f4: Expected O, but got Unknown
//IL_0154: Unknown result type (might be due to invalid IL or missing references)
//IL_0159: Unknown result type (might be due to invalid IL or missing references)
//IL_0162: 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_018d: Unknown result type (might be due to invalid IL or missing references)
//IL_0197: Expected O, but got Unknown
Log.LogDebug((object)("ActionName: " + a.name));
InputBinding val;
if (a.bindings.Count > 1)
{
int i;
for (i = 0; i < a.bindings.Count; i++)
{
if (DeviceNames.Any(delegate(string d)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
InputBinding val3 = a.bindings[i];
return ((InputBinding)(ref val3)).effectivePath.Contains(d, StringComparison.CurrentCultureIgnoreCase);
}))
{
ConfigFile config = ((BaseUnityPlugin)this).Config;
val = a.bindings[i];
string text = $"{((InputBinding)(ref val)).action} {i}";
val = a.bindings[i];
string text2 = ((InputBinding)(ref val)).effectivePath ?? "";
List<string> validKeyPaths = ValidKeyPaths;
int num = 0;
string[] array = new string[1 + validKeyPaths.Count];
foreach (string item in validKeyPaths)
{
array[num] = item;
num++;
}
int num2 = num;
val = a.bindings[i];
array[num2] = ((InputBinding)(ref val)).effectivePath;
ConfigEntry<string> config2 = config.Bind<string>("Bindings", text, text2, new ConfigDescription("", (AcceptableValueBase)(object)new AcceptableValueList<string>(array), Array.Empty<object>()));
BindManager bindManager = new BindManager(a, i, config2);
}
}
}
else if (DeviceNames.Any(delegate(string d)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
InputBinding val2 = a.bindings[0];
return ((InputBinding)(ref val2)).effectivePath.Contains(d, StringComparison.CurrentCultureIgnoreCase);
}))
{
ConfigFile config3 = ((BaseUnityPlugin)this).Config;
val = a.bindings[0];
string text3 = ((InputBinding)(ref val)).action ?? "";
val = a.bindings[0];
string text4 = ((InputBinding)(ref val)).effectivePath ?? "";
List<string> validKeyPaths2 = ValidKeyPaths;
int num3 = 0;
string[] array2 = new string[1 + validKeyPaths2.Count];
foreach (string item2 in validKeyPaths2)
{
array2[num3] = item2;
num3++;
}
int num4 = num3;
val = a.bindings[0];
array2[num4] = ((InputBinding)(ref val)).effectivePath;
ConfigEntry<string> config4 = config3.Bind<string>("Bindings", text3, text4, new ConfigDescription("", (AcceptableValueBase)(object)new AcceptableValueList<string>(array2), Array.Empty<object>()));
BindManager bindManager2 = new BindManager(a, 0, config4);
}
});
ParseAdditiveBinds();
((BaseUnityPlugin)this).Config.SettingChanged += OnSettingChanged;
((BaseUnityPlugin)this).Config.ConfigReloaded += OnConfigReloaded;
}
private void OnConfigReloaded(object sender, EventArgs e)
{
Log.LogDebug((object)"Config has been reloaded!");
BindManager.CheckAll();
}
private void OnSettingChanged(object sender, SettingChangedEventArgs settingChangedArg)
{
if (settingChangedArg.ChangedSetting != null && settingChangedArg.ChangedSetting is ConfigEntry<string> val)
{
if (val != BindsAdded)
{
BindManager.UpdateFromConfig(val);
}
else
{
ParseAdditiveBinds();
}
}
}
private static void ParseAdditiveBinds()
{
ManualBind.ClearAll();
if (string.IsNullOrEmpty(BindsAdded.Value))
{
return;
}
string[] array = BindsAdded.Value.Split(';', StringSplitOptions.RemoveEmptyEntries);
foreach (string text in array)
{
string text2 = text.Trim();
if (string.IsNullOrEmpty(text2))
{
continue;
}
string[] array2 = text2.Split(':', 2);
if (array2.Length == 2)
{
string action = array2[0].Trim();
string value = array2[1].Trim();
InputAction val = ((IEnumerable<InputAction>)InputSystem.actions).FirstOrDefault((Func<InputAction, bool>)((InputAction d) => d.name == action));
if (val != null)
{
ManualBind manualBind = new ManualBind(val, value);
}
}
}
}
private static List<string> GenerateValidKeyPaths()
{
//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_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
List<string> list = new List<string>();
List<string> source = new List<string>(1) { "/Keyboard/anyKey" };
DeviceNames = new List<string>();
Log.LogMessage((object)"Enable debug logging to see ALL valid binding keypaths!");
Enumerator<InputDevice> enumerator = InputSystem.devices.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
InputDevice current = enumerator.Current;
if (current == null)
{
continue;
}
DeviceNames.Add(((InputControl)current).displayName);
Enumerator<InputControl> enumerator2 = current.allControls.GetEnumerator();
try
{
while (enumerator2.MoveNext())
{
InputControl control = enumerator2.Current;
if (!source.Any((string d) => d.Equals(control.path, StringComparison.InvariantCultureIgnoreCase)))
{
string text = control.path.TrimStart('/');
Log.LogDebug((object)("Binding Keypath: " + text));
list.Add(text);
}
}
}
finally
{
((IDisposable)enumerator2).Dispose();
}
}
return list;
}
finally
{
((IDisposable)enumerator).Dispose();
}
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
