using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.InputSystem;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("EDCOMouseSteering")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+625c8389ba7b01ed26f9ef2637adae303c2018e4")]
[assembly: AssemblyProduct("EDCOMouseSteering")]
[assembly: AssemblyTitle("EDCOMouseSteering")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[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 EDCOMouseSteering
{
[BepInPlugin("EDCOMouseSteering", "EDCOMouseSteering", "1.0.0")]
public class EdcoMouseSteering : BaseUnityPlugin
{
private float _sensitivity = 1f;
private InputActionAsset _customAsset;
private InputActionMap _customMap;
private InputAction _toggleMouseSteering;
private InputAction _lookAction;
private InputAction _decreaseSensitivity;
private InputAction _increaseSensitivity;
private bool _isInitialized;
public static EdcoMouseSteering Instance { get; private set; }
public bool MouseSteeringEnabled { get; private set; }
public float MouseSteeringValue { get; private set; }
private void Awake()
{
if (!Object.op_Implicit((Object)(object)Instance))
{
Instance = this;
}
}
private void Update()
{
//IL_004c: 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_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: 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)
if (!_isInitialized)
{
try
{
InitializeInputAndPatches();
_isInitialized = true;
((BaseUnityPlugin)this).Logger.LogInfo((object)"EDCOMouseSteering: Ввод и Harmony-патчи успешно инициализированы!");
}
catch (TypeLoadException)
{
return;
}
}
if (_lookAction != null)
{
Vector2 val = _lookAction.ReadValue<Vector2>();
if (val != Vector2.zero && MouseSteeringEnabled && !PauseSystem.paused)
{
MouseSteeringValue = Mathf.Clamp(MouseSteeringValue + val.x / 25f * _sensitivity * Time.deltaTime * 10f, -1f, 1f);
}
}
}
private void InitializeInputAndPatches()
{
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
//IL_010b: Unknown result type (might be due to invalid IL or missing references)
//IL_0111: Expected O, but got Unknown
_customAsset = ScriptableObject.CreateInstance<InputActionAsset>();
_customMap = InputActionSetupExtensions.AddActionMap(_customAsset, "ModInputMap");
_toggleMouseSteering = InputActionSetupExtensions.AddAction(_customMap, "ToggleMouseSteering", (InputActionType)0, "<Mouse>/leftButton", (string)null, (string)null, (string)null, (string)null);
_lookAction = InputActionSetupExtensions.AddAction(_customMap, "MouseLook", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);
InputActionSetupExtensions.AddBinding(_lookAction, "<Mouse>/delta", (string)null, (string)null, (string)null);
_decreaseSensitivity = InputActionSetupExtensions.AddAction(_customMap, "DecreaseSensitivity", (InputActionType)0, "<Keyboard>/minus", (string)null, (string)null, (string)null, (string)null);
_increaseSensitivity = InputActionSetupExtensions.AddAction(_customMap, "IncreaseSensitivity", (InputActionType)0, "<Keyboard>/equals", (string)null, (string)null, (string)null, (string)null);
_toggleMouseSteering.performed += OnToggleMouseSteering;
_decreaseSensitivity.performed += OnDecreaseSensitivity;
_increaseSensitivity.performed += OnIncreaseSensitivity;
_customAsset.Enable();
Harmony val = new Harmony("com.flyen256.mousesteering");
val.PatchAll();
}
private void OnDestroy()
{
if (_toggleMouseSteering != null)
{
_toggleMouseSteering.performed -= OnToggleMouseSteering;
}
if (_decreaseSensitivity != null)
{
_decreaseSensitivity.performed -= OnDecreaseSensitivity;
}
if (_increaseSensitivity != null)
{
_increaseSensitivity.performed -= OnIncreaseSensitivity;
}
if (Object.op_Implicit((Object)(object)_customAsset))
{
_customAsset.Disable();
Object.Destroy((Object)(object)_customAsset);
}
}
private void OnToggleMouseSteering(CallbackContext context)
{
if (!PauseSystem.paused)
{
MouseSteeringEnabled = !MouseSteeringEnabled;
MouseSteeringValue = 0f;
((BaseUnityPlugin)this).Logger.LogInfo((object)$"Mouse steering toggled: {MouseSteeringEnabled}");
}
}
private void OnIncreaseSensitivity(CallbackContext context)
{
_sensitivity += 0.05f;
((BaseUnityPlugin)this).Logger.LogInfo((object)$"Sensitivity increased: {_sensitivity:F2}");
}
private void OnDecreaseSensitivity(CallbackContext context)
{
_sensitivity = Mathf.Max(0.01f, _sensitivity - 0.05f);
((BaseUnityPlugin)this).Logger.LogInfo((object)$"Sensitivity decreased: {_sensitivity:F2}");
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "EDCOMouseSteering";
public const string PLUGIN_NAME = "EDCOMouseSteering";
public const string PLUGIN_VERSION = "1.0.0";
}
}
namespace EDCOMouseSteering.Patches
{
[HarmonyPatch(typeof(sCameraRotate), "Update")]
public class CameraRotate_Update_Prefix
{
public static bool Prefix(sCameraRotate __instance, ref sCarController ___car, ref Vector3 ___rotation, ref Vector3 ___targetRotation)
{
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0078: 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)
//IL_0089: 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_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
if (!Object.op_Implicit((Object)(object)EdcoMouseSteering.Instance) || !EdcoMouseSteering.Instance.MouseSteeringEnabled)
{
return true;
}
if (PauseSystem.paused)
{
Cursor.lockState = (CursorLockMode)0;
return true;
}
Cursor.lockState = (CursorLockMode)1;
Vector3 linearVelocity = ___car.rb.linearVelocity;
float num = ((Vector3)(ref linearVelocity)).magnitude / 10f;
if (___car.GuyActive)
{
num = 0.5f;
}
___targetRotation = Vector3.Lerp(___targetRotation, Vector3.zero, Time.deltaTime * num);
___rotation = Vector3.Lerp(___rotation, ___targetRotation, Time.deltaTime * 4f);
__instance.target.localEulerAngles = Vector3.right * ___rotation.y;
__instance.pivot.localEulerAngles = Vector3.up * ___rotation.x;
return false;
}
}
[HarmonyPatch(typeof(sCarController), "Move")]
public class CarController_Move_Prefix
{
public static void Prefix(sCarController __instance, ref Vector2 ___targetInput)
{
if (EdcoMouseSteering.Instance.MouseSteeringEnabled)
{
__instance.input.x = EdcoMouseSteering.Instance.MouseSteeringValue;
}
}
}
[HarmonyPatch(typeof(sCarController), "SetInput", new Type[] { typeof(Vector2) })]
public static class CarController_SetInput_Postfix
{
public static void Postfix(sCarController __instance, ref Vector2 input, ref Vector2 ___targetInput)
{
___targetInput.x = input.x;
}
}
[HarmonyPatch(typeof(sInputManager), "GetInput")]
public static class InputManager_GetInput_Postfix
{
public static void Postfix(sInputManager __instance)
{
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
EdcoMouseSteering instance = EdcoMouseSteering.Instance;
if (Object.op_Implicit((Object)(object)instance) && instance.MouseSteeringEnabled)
{
__instance.driveInput = new Vector2(instance.MouseSteeringValue, __instance.driveInput.y);
}
}
}
}
