using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
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.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Rewired;
using Rewired.Data;
using Rewired.Utils.Libraries.TinyJson;
using UnityEngine;
using YawOnMouse.Blacklist;
using YawOnMouse.Helpers;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("YawOnMouse")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.1.0.0")]
[assembly: AssemblyInformationalVersion("1.1.0+40e90b669fbd0d69d7af571261dd1f8347f812c5")]
[assembly: AssemblyProduct("YawOnMouse")]
[assembly: AssemblyTitle("YawOnMouse")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.0.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.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace YawOnMouse
{
public enum AxisPatchType
{
Roll = 0,
Yaw = 2
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "YawOnMouse";
public const string PLUGIN_NAME = "YawOnMouse";
public const string PLUGIN_VERSION = "2.1.0";
}
[BepInPlugin("YawOnMouse", "YawOnMouse", "2.1.0")]
public class Plugin : BaseUnityPlugin
{
internal static ManualLogSource Logger;
public static ConfigEntry<bool> Enabled;
public static ConfigEntry<AxisPatchType> AxisPatchType;
public static ConfigEntry<bool> UseCraftWhitelist;
public WhitelistConfigManager WhitelistConfigManager;
public static Plugin Instance;
public const string ACTION_TOGGLE = "YawOnMouse::Toggle";
public static bool RewiredReady;
private bool _scanComplete;
private void Awake()
{
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
Logger = ((BaseUnityPlugin)this).Logger;
Instance = this;
WhitelistConfigManager = new WhitelistConfigManager();
Enabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Config", "PlayerAxisControls_Patch", true, "Enable/Disable controller roll input patch");
AxisPatchType = ((BaseUnityPlugin)this).Config.Bind<AxisPatchType>("Config", "AxisPatchType", YawOnMouse.AxisPatchType.Yaw, "What you want the patch to do on the x-axis (can only be changed before startup not at runtime.)");
UseCraftWhitelist = ((BaseUnityPlugin)this).Config.Bind<bool>("Config", "UseCraftWhitelist", false, "When enabled the mod will only work on the aircraft specified in the whitelist");
Logger.LogInfo((object)"Plugin YawOnMouse is loaded!");
new Harmony("YawOnMouse").PatchAll();
}
private void Update()
{
if (RewiredReady)
{
PlayerHelper players = ReInput.players;
Player val = ((players != null) ? players.GetPlayer(0) : null);
if (val != null && val.GetButtonDown("YawOnMouse::Toggle"))
{
Enabled.Value = !Enabled.Value;
((BaseUnityPlugin)this).Config.Save();
}
}
if (!_scanComplete)
{
_scanComplete = WhitelistConfigManager.TryScanForAircraft();
}
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "YawOnMouse";
public const string PLUGIN_NAME = "YawOnMouse";
public const string PLUGIN_VERSION = "1.1.0";
}
}
namespace YawOnMouse.Blacklist
{
public class WhitelistConfig
{
public Dictionary<string, bool> Whitelist = new Dictionary<string, bool>();
public bool Enabled(string name)
{
foreach (KeyValuePair<string, bool> item in Whitelist)
{
if (name.Contains(item.Key) && item.Value)
{
return true;
}
}
return false;
}
public void Add(string name, bool enabled)
{
Whitelist.Add(name, enabled);
}
public void Remove(string name)
{
Whitelist.Remove(name);
}
}
public class WhitelistConfigManager
{
private readonly string _whitelistConfigPath;
public WhitelistConfig Config { get; private set; }
public WhitelistConfigManager()
{
_whitelistConfigPath = Path.Combine(Paths.ConfigPath, "AircraftWhitelistConfig.json");
LoadOrCreateConfig();
}
public bool TryScanForAircraft()
{
Aircraft[] array = Resources.FindObjectsOfTypeAll<Aircraft>();
Plugin.Logger.LogInfo((object)$"Aircraft scan: found {((array != null) ? array.Length : 0)}");
if (array == null || array.Length == 0)
{
return false;
}
bool flag = false;
Aircraft[] array2 = array;
for (int i = 0; i < array2.Length; i++)
{
string text = ((Object)((Component)array2[i]).gameObject).name.Replace("(Clone)", "").Trim();
if (!Config.Whitelist.ContainsKey(text))
{
Config.Whitelist.Add(text, value: false);
Plugin.Logger.LogInfo((object)("Discovered " + text));
flag = true;
}
}
if (flag)
{
SaveConfig();
}
return true;
}
private void LoadOrCreateConfig()
{
if (!File.Exists(_whitelistConfigPath))
{
Config = GenerateDefaultConfig();
SaveConfig();
Plugin.Logger.LogInfo((object)("Config file " + _whitelistConfigPath + " has been created!"));
return;
}
try
{
string text = File.ReadAllText(_whitelistConfigPath);
Config = JsonParser.FromJson<WhitelistConfig>(text);
Plugin.Logger.LogInfo((object)"permission config loaded.");
}
catch (Exception ex)
{
Plugin.Logger.LogError((object)("failed to load permission config: " + ex.Message));
Config = GenerateDefaultConfig();
SaveConfig();
}
}
private void SaveConfig()
{
try
{
string contents = JsonWriter.ToJson((object)Config);
File.WriteAllText(_whitelistConfigPath, contents);
Plugin.Logger.LogInfo((object)"permission config saved.");
}
catch (Exception ex)
{
Plugin.Logger.LogError((object)("failed to save permission config: " + ex.Message));
}
}
private WhitelistConfig GenerateDefaultConfig()
{
return new WhitelistConfig
{
Whitelist = new Dictionary<string, bool>()
};
}
}
}
namespace YawOnMouse.Patches
{
public class PilotPlayerStatePatches
{
[HarmonyPatch(typeof(PilotPlayerState), "PlayerAxisControls")]
private static class PlayerAxisControls
{
private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
{
List<CodeInstruction> list = new List<CodeInstruction>(instructions);
if (Plugin.AxisPatchType.Value == AxisPatchType.Roll)
{
return instructions;
}
if (Plugin.AxisPatchType.Value == AxisPatchType.Yaw)
{
return Yaw(list, il);
}
return list;
}
private static IEnumerable<CodeInstruction> Yaw(List<CodeInstruction> codes, ILGenerator il)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Expected O, but got Unknown
//IL_0128: Unknown result type (might be due to invalid IL or missing references)
//IL_012f: Expected O, but got Unknown
//IL_015e: Unknown result type (might be due to invalid IL or missing references)
//IL_0168: Expected O, but got Unknown
//IL_0175: Unknown result type (might be due to invalid IL or missing references)
//IL_017f: Expected O, but got Unknown
//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
//IL_01b5: Expected O, but got Unknown
//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
//IL_00d5: Expected O, but got Unknown
CodeMatcher val = new CodeMatcher((IEnumerable<CodeInstruction>)codes, (ILGenerator)null);
MatchRollInputInstruction(val, useEnd: false);
if (val.IsInvalid)
{
Plugin.Logger.LogError((object)"Could not find instructions for Yaw");
return codes;
}
int pos = val.Pos;
List<Label> collection = new List<Label>(codes[pos].labels);
MatchRollInputInstruction(val, useEnd: true);
int pos2 = val.Pos;
List<CodeInstruction> range = codes.GetRange(pos, pos2 - pos + 1);
List<CodeInstruction> list = new List<CodeInstruction>();
foreach (CodeInstruction item in range)
{
if (item.opcode == OpCodes.Stfld && item.operand is FieldInfo fieldInfo && fieldInfo.Name == "rollInput")
{
list.Add(new CodeInstruction(OpCodes.Stfld, (object)AccessTools.Field(typeof(PilotPlayerState), "yawInput")));
}
else
{
list.Add(item.Clone());
}
}
Label label = il.DefineLabel();
Label label2 = il.DefineLabel();
list[0].labels.Add(label);
CodeInstruction val2 = new CodeInstruction(OpCodes.Nop, (object)null);
val2.labels.Add(label2);
List<CodeInstruction> list2 = new List<CodeInstruction>
{
new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(PatchHelper), "ShouldUseYaw", (Type[])null, (Type[])null)),
new CodeInstruction(OpCodes.Brtrue_S, (object)label)
};
list2[0].labels.AddRange(collection);
list2.AddRange(range);
list2.Add(new CodeInstruction(OpCodes.Br_S, (object)label2));
list2.AddRange(list);
list2.Add(val2);
codes.RemoveRange(pos, pos2 - pos + 1);
codes.InsertRange(pos, list2);
return codes;
}
private static void MatchRollInputInstruction(CodeMatcher codeMatcher, bool useEnd)
{
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Expected O, but got Unknown
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Expected O, but got Unknown
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Expected O, but got Unknown
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Expected O, but got Unknown
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Expected O, but got Unknown
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Expected O, but got Unknown
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_0095: Expected O, but got Unknown
//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
//IL_00a9: Expected O, but got Unknown
//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
//IL_00d0: Expected O, but got Unknown
codeMatcher.MatchForward(useEnd, (CodeMatch[])(object)new CodeMatch[9]
{
new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldsfld, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Callvirt, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Callvirt, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Div, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Stfld, (object)AccessTools.Field(typeof(PilotPlayerState), "rollInput"), (string)null)
});
}
}
}
[HarmonyPatch(typeof(InputManager_Base), "Awake")]
internal static class RewiredAwakePatches
{
private const string TargetCategory = "flight";
private const int ActionID = 850;
[HarmonyPrefix]
private static void Prefix(InputManager_Base __instance)
{
//IL_0123: Unknown result type (might be due to invalid IL or missing references)
//IL_012a: Expected O, but got Unknown
try
{
UserData userData = __instance.userData;
if (userData == null)
{
return;
}
IList field = GetField<IList>(userData, "actionCategories");
IList field2 = GetField<IList>(userData, "actions");
if (field == null || field2 == null)
{
return;
}
object obj = null;
foreach (object item in field)
{
if (string.Equals(GetProp<string>(item, "name"), "flight", StringComparison.OrdinalIgnoreCase))
{
obj = item;
break;
}
}
if (obj == null)
{
Plugin.Logger.LogWarning((object)"[YawOnMouse] Flight category not found — toggle action will not be registered");
return;
}
bool flag = false;
int num = 850;
foreach (object item2 in field2)
{
if (GetProp<string>(item2, "name") == "YawOnMouse::Toggle")
{
flag = true;
}
int prop = GetProp<int>(item2, "id");
if (prop >= num)
{
num = prop + 1;
}
}
if (!flag)
{
Type typeFromHandle = typeof(InputAction);
InputAction val = (InputAction)Activator.CreateInstance(typeFromHandle, nonPublic: true);
SetProp(typeFromHandle, val, "id", num);
SetProp(typeFromHandle, val, "name", "YawOnMouse::Toggle");
SetProp<InputActionType>(typeFromHandle, val, "type", (InputActionType)1);
SetProp(typeFromHandle, val, "descriptiveName", "Yaw On Mouse Toggle");
int prop2 = GetProp<int>(obj, "id");
SetProp(typeFromHandle, val, "categoryId", prop2);
SetField(typeFromHandle, val, "_userAssignable", value: true);
field2.Add(val);
object field3 = GetField<object>(userData, "actionCategoryMap");
if (field3 != null)
{
AccessTools.Method(field3.GetType(), "AddAction", new Type[2]
{
typeof(int),
typeof(int)
}, (Type[])null)?.Invoke(field3, new object[2] { prop2, num });
}
Plugin.RewiredReady = true;
Plugin.Logger.LogInfo((object)"[YawOnMouse] Registered toggle action in Flight category");
}
}
catch (Exception arg)
{
Plugin.Logger.LogError((object)$"[YawOnMouse] Action registration: {arg}");
}
}
private static T GetProp<T>(object instance, string name)
{
return (T)(AccessTools.Property(instance.GetType(), name)?.GetValue(instance) ?? ((object)default(T)));
}
private static void SetProp<T>(Type type, object instance, string name, T value)
{
AccessTools.Property(type, name)?.SetValue(instance, value, null);
}
private static T GetField<T>(object instance, string name)
{
return (T)(AccessTools.Field(instance.GetType(), name)?.GetValue(instance) ?? ((object)default(T)));
}
private static void SetField<T>(Type type, object instance, string name, T value)
{
AccessTools.Field(type, name)?.SetValue(instance, value);
}
}
}
namespace YawOnMouse.Helpers
{
public static class PatchHelper
{
public static bool ShouldUseYaw()
{
if (Plugin.Enabled.Value && Plugin.AxisPatchType.Value == AxisPatchType.Yaw)
{
return WhitelistHelper.IsWhitelisted();
}
return false;
}
}
public static class WhitelistHelper
{
public static bool IsWhitelisted()
{
if (!Plugin.UseCraftWhitelist.Value)
{
return true;
}
Aircraft val = default(Aircraft);
if (!GameManager.GetLocalAircraft(ref val))
{
return false;
}
string name = ((Object)((Component)val).gameObject).name;
return Plugin.Instance.WhitelistConfigManager.Config.Enabled(name);
}
}
}
