using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Dissonance;
using Dissonance.Audio.Capture;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.SceneManagement;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("LCMicRecovery")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("LCMicRecovery")]
[assembly: AssemblyCopyright("")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("a1b2c3d4-e5f6-4789-abcd-1234567890ab")]
[assembly: AssemblyFileVersion("0.3.5.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("0.3.5.0")]
[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 LCMicRecovery
{
[BepInPlugin("com.yourname.lcmicrecovery", "LC Mic Recovery", "0.3.5")]
public class Plugin : BaseUnityPlugin
{
internal static Plugin Instance;
internal static Harmony HarmonyInstance;
internal static ManualLogSource Log;
private void Awake()
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Expected O, but got Unknown
//IL_0065: 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_0070: Expected O, but got Unknown
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
Instance = this;
Log = ((BaseUnityPlugin)this).Logger;
PluginConfig.Bind(((BaseUnityPlugin)this).Config);
HarmonyInstance = new Harmony("com.yourname.lcmicrecovery");
HarmonyInstance.PatchAll();
Log.LogInfo((object)"LC Mic Recovery loaded.");
Log.LogInfo((object)"LC Mic Recovery version: 0.3.5");
if ((Object)(object)Object.FindObjectOfType<MicRecoveryWatcher>() == (Object)null)
{
GameObject val = new GameObject("LCMicRecovery_Watcher");
Object.DontDestroyOnLoad((Object)val);
((Object)val).hideFlags = (HideFlags)61;
val.AddComponent<MicRecoveryWatcher>();
Log.LogInfo((object)"LCMicRecovery_Watcher created successfully.");
}
else
{
Log.LogInfo((object)"LCMicRecovery_Watcher already exists, skipping duplicate creation.");
}
Log.LogInfo((object)"Config entries bound. Check LethalConfig in-game to see if they appear.");
}
}
internal static class PluginConfig
{
internal static ConfigEntry<bool> EnableMod;
internal static ConfigEntry<bool> EnableDebugLog;
internal static ConfigEntry<bool> EnableStateLogs;
internal static ConfigEntry<bool> EnableHeartbeatLog;
internal static ConfigEntry<bool> ShowFiveStepRecoveryLogs;
internal static ConfigEntry<bool> EnablePreRoundSkipLog;
internal static ConfigEntry<bool> LogPreRoundSkipOnlyOnce;
internal static ConfigEntry<bool> SuspendAutoRecoveryWhenNoDevices;
internal static ConfigEntry<bool> EnableNoDeviceSuspendLog;
internal static ConfigEntry<bool> LogNoDeviceSuspendOnlyOnce;
internal static ConfigEntry<bool> AllowManualRecoveryWhenNoDevices;
internal static ConfigEntry<bool> SuspendAutoRecoveryDuringMenuOrTeardown;
internal static ConfigEntry<float> LobbyExitSuspendSeconds;
internal static ConfigEntry<bool> EnableTeardownSuspendLog;
internal static ConfigEntry<bool> LogTeardownSuspendOnlyOnce;
internal static ConfigEntry<bool> EnableManualRecoveryKey;
internal static ConfigEntry<Key> ManualRecoveryKey;
internal static ConfigEntry<bool> EnableAutoRecovery;
internal static ConfigEntry<bool> EnablePreRoundRecovery;
internal static ConfigEntry<float> AutoCheckIntervalSeconds;
internal static ConfigEntry<float> RecoveryCooldownSeconds;
internal static ConfigEntry<float> PostRecoveryGraceSeconds;
internal static ConfigEntry<string> PreferredDeviceKeywords;
internal static ConfigEntry<bool> PreferCurrentDeviceIfStillExists;
internal static ConfigEntry<bool> RecoverWhenMicNameEmpty;
internal static ConfigEntry<bool> RecoverWhenDeviceMissing;
internal static ConfigEntry<bool> RecoverWhenUnityNotRecording;
internal static bool DebugEnabled
{
get
{
if (EnableDebugLog != null)
{
return EnableDebugLog.Value;
}
return false;
}
}
internal static bool StateLogsEnabled
{
get
{
if (EnableStateLogs != null)
{
return EnableStateLogs.Value;
}
return false;
}
}
internal static bool HeartbeatEnabled
{
get
{
if (EnableHeartbeatLog != null)
{
return EnableHeartbeatLog.Value;
}
return false;
}
}
internal static void Bind(ConfigFile config)
{
EnableMod = config.Bind<bool>("General", "EnableMod", true, "总开关。关闭后模组不执行任何恢复逻辑。");
EnableDebugLog = config.Bind<bool>("Logging", "EnableDebugLog", false, "是否输出调试日志。正常游玩建议关闭。");
EnableStateLogs = config.Bind<bool>("Logging", "EnableStateLogs", false, "是否输出状态检测日志（当前麦克风、IsRecording 等，容易刷屏）。正常游玩建议关闭。");
EnableHeartbeatLog = config.Bind<bool>("Logging", "EnableHeartbeatLog", false, "是否输出 watcher 心跳日志。正常游玩建议关闭。");
ShowFiveStepRecoveryLogs = config.Bind<bool>("Logging", "ShowFiveStepRecoveryLogs", true, "恢复时是否输出 1/5 到 5/5 的明显日志。正常游玩建议开启。");
EnablePreRoundSkipLog = config.Bind<bool>("Logging", "EnablePreRoundSkipLog", false, "在 StartOfRound 尚未就绪时，是否输出“跳过自动恢复检测”的日志。正常游玩建议关闭。");
LogPreRoundSkipOnlyOnce = config.Bind<bool>("Logging", "LogPreRoundSkipOnlyOnce", true, "是否只在每次进入局内前打印一次“StartOfRound 尚未就绪”的日志。");
SuspendAutoRecoveryWhenNoDevices = config.Bind<bool>("No Device Handling", "SuspendAutoRecoveryWhenNoDevices", true, "当没有检测到任何录音设备时，暂停自动恢复，避免反复刷恢复日志。");
EnableNoDeviceSuspendLog = config.Bind<bool>("No Device Handling", "EnableNoDeviceSuspendLog", false, "当没有录音设备时，是否输出“已暂停自动恢复”的提示日志。");
LogNoDeviceSuspendOnlyOnce = config.Bind<bool>("No Device Handling", "LogNoDeviceSuspendOnlyOnce", true, "没有录音设备时，是否只打印一次“已暂停自动恢复”的提示。");
AllowManualRecoveryWhenNoDevices = config.Bind<bool>("No Device Handling", "AllowManualRecoveryWhenNoDevices", false, "当没有录音设备时，是否允许手动按键继续强制恢复。");
SuspendAutoRecoveryDuringMenuOrTeardown = config.Bind<bool>("Teardown Handling", "SuspendAutoRecoveryDuringMenuOrTeardown", true, "当处于主菜单/大厅，或房间正在退出销毁时，暂停自动恢复。建议开启。");
LobbyExitSuspendSeconds = config.Bind<float>("Teardown Handling", "LobbyExitSuspendSeconds", 8f, "退出房间或切换到大厅后，暂停自动恢复的秒数。建议 8。");
EnableTeardownSuspendLog = config.Bind<bool>("Teardown Handling", "EnableTeardownSuspendLog", false, "当因为大厅/退出阶段而暂停自动恢复时，是否输出提示日志。");
LogTeardownSuspendOnlyOnce = config.Bind<bool>("Teardown Handling", "LogTeardownSuspendOnlyOnce", true, "是否只打印一次大厅/退出阶段挂起日志。");
EnableManualRecoveryKey = config.Bind<bool>("Manual Recovery", "EnableManualRecoveryKey", true, "是否启用手动按键恢复。");
ManualRecoveryKey = config.Bind<Key>("Manual Recovery", "ManualRecoveryKey", (Key)101, "手动触发恢复的按键。");
EnableAutoRecovery = config.Bind<bool>("Auto Recovery", "EnableAutoRecovery", true, "是否启用自动恢复。");
EnablePreRoundRecovery = config.Bind<bool>("Auto Recovery", "EnablePreRoundRecovery", false, "是否允许在 StartOfRound 出现前就触发恢复。建议关闭。");
AutoCheckIntervalSeconds = config.Bind<float>("Auto Recovery", "AutoCheckIntervalSeconds", 3f, "自动检测间隔（秒）。");
RecoveryCooldownSeconds = config.Bind<float>("Auto Recovery", "RecoveryCooldownSeconds", 10f, "两次恢复之间的冷却时间（秒）。");
PostRecoveryGraceSeconds = config.Bind<float>("Auto Recovery", "PostRecoveryGraceSeconds", 4f, "恢复完成后的宽限时间（秒）。");
PreferredDeviceKeywords = config.Bind<string>("Device", "PreferredDeviceKeywords", "Maxwell,Audeze", "优先匹配的设备关键词，多个用英文逗号分隔。");
PreferCurrentDeviceIfStillExists = config.Bind<bool>("Device", "PreferCurrentDeviceIfStillExists", true, "如果当前设备仍存在，恢复时优先保持当前设备。");
RecoverWhenMicNameEmpty = config.Bind<bool>("Recovery Conditions", "RecoverWhenMicNameEmpty", true, "当前麦克风名称为空时是否触发恢复。");
RecoverWhenDeviceMissing = config.Bind<bool>("Recovery Conditions", "RecoverWhenDeviceMissing", true, "当前麦克风不在设备列表中时是否触发恢复。");
RecoverWhenUnityNotRecording = config.Bind<bool>("Recovery Conditions", "RecoverWhenUnityNotRecording", true, "Unity 报告当前麦克风未在录音时是否触发恢复。");
}
}
public class MicRecoveryWatcher : MonoBehaviour
{
private float _checkTimer;
private float _heartbeatTimer;
private float _nextCommsSearchTime;
private float _suspendRecoveryUntil = -999f;
private bool _preRoundSkipLogged;
private bool _noDeviceSuspendLogged;
private bool _teardownSuspendLogged;
private int _autoDeviceListFailureCount;
private DissonanceComms _cachedComms;
private readonly List<string> _deviceBuffer = new List<string>(8);
private void OnEnable()
{
SceneManager.activeSceneChanged += OnActiveSceneChanged;
}
private void OnDisable()
{
SceneManager.activeSceneChanged -= OnActiveSceneChanged;
}
private void OnActiveSceneChanged(Scene oldScene, Scene newScene)
{
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
_cachedComms = null;
_nextCommsSearchTime = 0f;
_preRoundSkipLogged = false;
_noDeviceSuspendLogged = false;
_teardownSuspendLogged = false;
_autoDeviceListFailureCount = 0;
if (PluginConfig.SuspendAutoRecoveryDuringMenuOrTeardown != null && PluginConfig.SuspendAutoRecoveryDuringMenuOrTeardown.Value && IsMenuScene(newScene))
{
SuspendRecoveryForTeardown("切换到主菜单/大厅场景，已暂停自动恢复。");
}
}
private static bool IsMenuScene(Scene scene)
{
if (!((Scene)(ref scene)).IsValid())
{
return true;
}
return (((Scene)(ref scene)).name ?? string.Empty).IndexOf("menu", StringComparison.OrdinalIgnoreCase) >= 0;
}
private bool IsRecoveryTemporarilySuspended()
{
return Time.unscaledTime < _suspendRecoveryUntil;
}
private void SuspendRecoveryForTeardown(string reason)
{
float num = ((PluginConfig.LobbyExitSuspendSeconds != null) ? Mathf.Max(0f, PluginConfig.LobbyExitSuspendSeconds.Value) : 8f);
float num2 = Time.unscaledTime + num;
if (num2 > _suspendRecoveryUntil)
{
_suspendRecoveryUntil = num2;
}
if (PluginConfig.EnableTeardownSuspendLog != null && PluginConfig.EnableTeardownSuspendLog.Value && (PluginConfig.LogTeardownSuspendOnlyOnce == null || !PluginConfig.LogTeardownSuspendOnlyOnce.Value || !_teardownSuspendLogged))
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogInfo((object)("[MicRecovery] " + reason));
}
_teardownSuspendLogged = true;
}
}
private void Update()
{
if (PluginConfig.EnableMod != null && !PluginConfig.EnableMod.Value)
{
return;
}
HandleManualRecoveryKey();
HandleHeartbeat();
if (PluginConfig.EnableAutoRecovery == null || PluginConfig.EnableAutoRecovery.Value)
{
float num = ((PluginConfig.AutoCheckIntervalSeconds != null) ? Mathf.Max(0.5f, PluginConfig.AutoCheckIntervalSeconds.Value) : 3f);
_checkTimer += Time.unscaledDeltaTime;
if (!(_checkTimer < num))
{
_checkTimer = 0f;
AutoCheckMic();
}
}
}
private void HandleManualRecoveryKey()
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
if (PluginConfig.EnableManualRecoveryKey == null || !PluginConfig.EnableManualRecoveryKey.Value)
{
return;
}
try
{
Keyboard current = Keyboard.current;
if (current == null)
{
return;
}
Key value = PluginConfig.ManualRecoveryKey.Value;
if (!((ButtonControl)current[value]).wasPressedThisFrame)
{
return;
}
if (PluginConfig.SuspendAutoRecoveryDuringMenuOrTeardown != null && PluginConfig.SuspendAutoRecoveryDuringMenuOrTeardown.Value && MicRecoveryCore.IsMenuSceneActive())
{
if (PluginConfig.DebugEnabled)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogInfo((object)"[MicRecovery] 当前位于主菜单/大厅，已跳过手动恢复。");
}
}
return;
}
if (PluginConfig.SuspendAutoRecoveryDuringMenuOrTeardown != null && PluginConfig.SuspendAutoRecoveryDuringMenuOrTeardown.Value && !MicRecoveryCore.IsGameSideResetSafe())
{
if (PluginConfig.DebugEnabled)
{
ManualLogSource log2 = Plugin.Log;
if (log2 != null)
{
log2.LogInfo((object)"[MicRecovery] 当前处于退房、切场景或对象不稳定阶段，已跳过手动恢复。");
}
}
return;
}
DissonanceComms comms = GetComms();
if ((Object)(object)comms == (Object)null)
{
return;
}
_deviceBuffer.Clear();
bool flag = false;
try
{
comms.GetMicrophoneDevices(_deviceBuffer);
}
catch (Exception ex)
{
flag = true;
if (PluginConfig.DebugEnabled)
{
ManualLogSource log3 = Plugin.Log;
if (log3 != null)
{
log3.LogWarning((object)("[MicRecovery] 手动恢复获取录音设备列表失败，将继续尝试强制恢复：" + ex.Message));
}
}
}
if (!flag && _deviceBuffer.Count == 0 && PluginConfig.AllowManualRecoveryWhenNoDevices != null && !PluginConfig.AllowManualRecoveryWhenNoDevices.Value)
{
if (PluginConfig.DebugEnabled)
{
ManualLogSource log4 = Plugin.Log;
if (log4 != null)
{
log4.LogInfo((object)"[MicRecovery] 当前没有录音设备，已跳过手动恢复。");
}
}
}
else
{
MicRecoveryCore.TryRecover("手动按键触发恢复", ignoreCooldown: true);
}
}
catch (Exception ex2)
{
if (PluginConfig.DebugEnabled)
{
ManualLogSource log5 = Plugin.Log;
if (log5 != null)
{
log5.LogWarning((object)("[MicRecovery] 手动按键检测失败：" + ex2.Message));
}
}
}
}
private void HandleHeartbeat()
{
if (!PluginConfig.HeartbeatEnabled)
{
return;
}
_heartbeatTimer += Time.unscaledDeltaTime;
if (!(_heartbeatTimer < 15f))
{
_heartbeatTimer = 0f;
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogInfo((object)"[MicRecovery] Watcher 正在运行。");
}
}
}
private DissonanceComms GetComms()
{
Object cachedComms = (Object)(object)_cachedComms;
if (cachedComms != null && cachedComms == (Object)null)
{
_cachedComms = null;
}
if ((Object)(object)_cachedComms != (Object)null)
{
return _cachedComms;
}
if (Time.unscaledTime < _nextCommsSearchTime)
{
return null;
}
_nextCommsSearchTime = Time.unscaledTime + 1f;
_cachedComms = Object.FindObjectOfType<DissonanceComms>();
return _cachedComms;
}
private void AutoCheckMic()
{
try
{
if (PluginConfig.SuspendAutoRecoveryDuringMenuOrTeardown != null && PluginConfig.SuspendAutoRecoveryDuringMenuOrTeardown.Value)
{
if (MicRecoveryCore.IsMenuSceneActive())
{
SuspendRecoveryForTeardown("当前处于主菜单/大厅场景，已暂停自动恢复。");
return;
}
if (IsRecoveryTemporarilySuspended())
{
return;
}
}
DissonanceComms comms = GetComms();
if ((Object)(object)comms == (Object)null)
{
if (PluginConfig.DebugEnabled)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogInfo((object)"[MicRecovery] 当前未找到 DissonanceComms，跳过检测。");
}
}
return;
}
if (!PluginConfig.EnablePreRoundRecovery.Value && !MicRecoveryCore.IsStartOfRoundReady())
{
if (PluginConfig.EnablePreRoundSkipLog.Value && (!PluginConfig.LogPreRoundSkipOnlyOnce.Value || !_preRoundSkipLogged))
{
ManualLogSource log2 = Plugin.Log;
if (log2 != null)
{
log2.LogInfo((object)"[MicRecovery] StartOfRound 尚未就绪，跳过自动恢复检测。");
}
_preRoundSkipLogged = true;
}
return;
}
_preRoundSkipLogged = false;
if (PluginConfig.SuspendAutoRecoveryDuringMenuOrTeardown.Value && !MicRecoveryCore.IsGameSideResetSafe())
{
SuspendRecoveryForTeardown("检测到房间正在退出或语音上下文正在销毁，已暂停自动恢复。");
return;
}
_teardownSuspendLogged = false;
_deviceBuffer.Clear();
try
{
comms.GetMicrophoneDevices(_deviceBuffer);
}
catch (Exception ex)
{
_autoDeviceListFailureCount++;
if (PluginConfig.DebugEnabled)
{
ManualLogSource log3 = Plugin.Log;
if (log3 != null)
{
log3.LogWarning((object)$"[MicRecovery] 自动检测获取录音设备列表失败（{_autoDeviceListFailureCount}/2）：{ex.Message}");
}
}
if (_autoDeviceListFailureCount >= 2)
{
_autoDeviceListFailureCount = 0;
MicRecoveryCore.TryRecover("自动检测连续获取录音设备列表失败");
}
return;
}
_autoDeviceListFailureCount = 0;
if (PluginConfig.SuspendAutoRecoveryWhenNoDevices.Value && _deviceBuffer.Count == 0)
{
if (PluginConfig.EnableNoDeviceSuspendLog.Value && (!PluginConfig.LogNoDeviceSuspendOnlyOnce.Value || !_noDeviceSuspendLogged))
{
ManualLogSource log4 = Plugin.Log;
if (log4 != null)
{
log4.LogInfo((object)"[MicRecovery] 未检测到任何录音设备，已暂停自动恢复与相关状态日志。");
}
_noDeviceSuspendLogged = true;
}
return;
}
_noDeviceSuspendLogged = false;
string currentMicName;
try
{
currentMicName = comms.MicrophoneName;
}
catch (Exception ex2)
{
if (PluginConfig.DebugEnabled)
{
ManualLogSource log5 = Plugin.Log;
if (log5 != null)
{
log5.LogWarning((object)("[MicRecovery] 自动检测读取当前麦克风名称失败：" + ex2.Message));
}
}
MicRecoveryCore.TryRecover("自动检测读取当前麦克风名称失败");
return;
}
if (PluginConfig.RecoverWhenMicNameEmpty.Value && string.IsNullOrWhiteSpace(currentMicName))
{
MicRecoveryCore.TryRecover("当前 Dissonance 麦克风名称为空");
return;
}
bool isInPostRecoveryGracePeriod = MicRecoveryCore.IsInPostRecoveryGracePeriod;
if (!isInPostRecoveryGracePeriod)
{
try
{
IMicrophoneCapture microphoneCapture = comms.MicrophoneCapture;
if (microphoneCapture == null)
{
MicRecoveryCore.TryRecover("Dissonance 麦克风采集管线为空");
return;
}
if (!microphoneCapture.IsRecording)
{
MicRecoveryCore.TryRecover("Dissonance 麦克风采集管线未在录音");
return;
}
}
catch (Exception ex3)
{
if (PluginConfig.DebugEnabled)
{
ManualLogSource log6 = Plugin.Log;
if (log6 != null)
{
log6.LogWarning((object)("[MicRecovery] 读取 Dissonance 麦克风采集管线失败：" + ex3.Message));
}
}
}
}
else if (PluginConfig.DebugEnabled)
{
ManualLogSource log7 = Plugin.Log;
if (log7 != null)
{
log7.LogInfo((object)"[MicRecovery] 当前处于恢复宽限期，跳过 Dissonance 麦克风采集管线判定。");
}
}
bool flag = _deviceBuffer.Any((string d) => string.Equals(d, currentMicName, StringComparison.Ordinal));
if (PluginConfig.StateLogsEnabled)
{
ManualLogSource log8 = Plugin.Log;
if (log8 != null)
{
log8.LogInfo((object)$"[MicRecovery] 当前麦克风：{currentMicName} | 设备数：{_deviceBuffer.Count} | 设备仍存在：{flag}");
}
}
if (PluginConfig.RecoverWhenDeviceMissing.Value && !flag)
{
MicRecoveryCore.TryRecover("当前麦克风已不在设备列表中：" + currentMicName);
return;
}
if (isInPostRecoveryGracePeriod)
{
if (PluginConfig.DebugEnabled)
{
ManualLogSource log9 = Plugin.Log;
if (log9 != null)
{
log9.LogInfo((object)"[MicRecovery] 当前处于恢复宽限期，跳过 Unity.IsRecording 判定。");
}
}
return;
}
bool flag2 = false;
try
{
if (!string.IsNullOrWhiteSpace(currentMicName))
{
flag2 = Microphone.IsRecording(currentMicName);
}
}
catch (Exception ex4)
{
if (PluginConfig.DebugEnabled)
{
ManualLogSource log10 = Plugin.Log;
if (log10 != null)
{
log10.LogWarning((object)("[MicRecovery] 调用 Microphone.IsRecording 失败：" + ex4.Message));
}
}
}
if (PluginConfig.StateLogsEnabled)
{
ManualLogSource log11 = Plugin.Log;
if (log11 != null)
{
log11.LogInfo((object)$"[MicRecovery] Unity.IsRecording({currentMicName}) = {flag2}");
}
}
if (PluginConfig.RecoverWhenUnityNotRecording.Value && !flag2)
{
MicRecoveryCore.TryRecover("Unity 报告麦克风未在录音：" + currentMicName);
}
}
catch (Exception arg)
{
ManualLogSource log12 = Plugin.Log;
if (log12 != null)
{
log12.LogWarning((object)$"[MicRecovery] AutoCheckMic 异常：{arg}");
}
_cachedComms = null;
_nextCommsSearchTime = 0f;
}
}
}
internal static class MicRecoveryCore
{
private enum GameSideResetResult
{
Invoked,
SkippedUnsafe,
MethodNotFound,
Failed
}
[CompilerGenerated]
private sealed class <SafeRunGameSideResetCoroutine>d__19 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public IEnumerator routine;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <SafeRunGameSideResetCoroutine>d__19(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
int num = <>1__state;
if (num != 0)
{
if (num != 1)
{
return false;
}
<>1__state = -1;
}
else
{
<>1__state = -1;
}
bool flag = false;
bool flag2 = false;
object obj;
try
{
flag = routine.MoveNext();
obj = (flag ? routine.Current : null);
}
catch (Exception ex)
{
flag2 = true;
if (!_gameSideResetCoroutineWarningLogged)
{
_gameSideResetCoroutineWarningLogged = true;
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogWarning((object)("[MicRecovery] 游戏侧 ResetDissonanceCommsComponent 协程执行失败，已停止该协程并保留本地 ResetMicrophoneCapture 结果：" + ex.Message));
}
}
else if (PluginConfig.DebugEnabled)
{
ManualLogSource log2 = Plugin.Log;
if (log2 != null)
{
log2.LogWarning((object)("[MicRecovery] 游戏侧 ResetDissonanceCommsComponent 协程再次失败：" + ex.Message));
}
}
obj = null;
}
if (flag2 || !flag)
{
return false;
}
<>2__current = obj;
<>1__state = 1;
return true;
}
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 readonly BindingFlags InstanceFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
private static readonly BindingFlags StaticFlags = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
private static float _lastRecoveryTime = -999f;
private static float _postRecoveryGraceUntil = -999f;
private static bool _gameSideResetCompatibilityWarningLogged;
private static bool _gameSideResetCoroutineWarningLogged;
internal static bool IsInPostRecoveryGracePeriod => Time.unscaledTime < _postRecoveryGraceUntil;
internal static bool TryRecover(string reason)
{
return TryRecover(reason, ignoreCooldown: false);
}
internal static bool TryRecover(string reason, bool ignoreCooldown)
{
float num = ((PluginConfig.RecoveryCooldownSeconds != null) ? Mathf.Max(0f, PluginConfig.RecoveryCooldownSeconds.Value) : 10f);
if (!ignoreCooldown && Time.unscaledTime - _lastRecoveryTime < num)
{
if (PluginConfig.DebugEnabled)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogWarning((object)("[MicRecovery] 恢复冷却中，跳过本次恢复。reason=" + reason));
}
}
return false;
}
LogRecoveryStep(1, "检测到疑似麦克风失效，开始执行恢复");
LogRecoveryStep(2, "触发原因：" + reason);
try
{
DissonanceComms val = Object.FindObjectOfType<DissonanceComms>();
if ((Object)(object)val == (Object)null)
{
ManualLogSource log2 = Plugin.Log;
if (log2 != null)
{
log2.LogError((object)"========== [麦克风修复 3/5] 未找到 DissonanceComms，无法执行恢复 ==========");
}
ManualLogSource log3 = Plugin.Log;
if (log3 != null)
{
log3.LogError((object)"========== [麦克风修复 4/5] 本次恢复失败 ==========");
}
ManualLogSource log4 = Plugin.Log;
if (log4 != null)
{
log4.LogError((object)"========== [麦克风修复 5/5] 请检查当前场景是否已进入可语音状态 ==========");
}
return false;
}
string text = null;
try
{
text = val.MicrophoneName;
}
catch (Exception ex)
{
if (PluginConfig.DebugEnabled)
{
ManualLogSource log5 = Plugin.Log;
if (log5 != null)
{
log5.LogWarning((object)("[MicRecovery] 读取当前麦克风名称失败：" + ex.Message));
}
}
}
List<string> list = new List<string>();
try
{
val.GetMicrophoneDevices(list);
}
catch (Exception ex2)
{
if (PluginConfig.DebugEnabled)
{
ManualLogSource log6 = Plugin.Log;
if (log6 != null)
{
log6.LogWarning((object)("[MicRecovery] 获取麦克风列表失败：" + ex2.Message));
}
}
}
string[] array = list.ToArray();
LogRecoveryStep(3, string.Format("当前麦克风：{0} | 设备数：{1}", string.IsNullOrEmpty(text) ? "<空>" : text, array.Length));
string text2 = PickPreferredDevice(array, text);
if (!string.IsNullOrEmpty(text2))
{
if (!string.Equals(text, text2, StringComparison.Ordinal))
{
val.MicrophoneName = text2;
if (PluginConfig.DebugEnabled)
{
ManualLogSource log7 = Plugin.Log;
if (log7 != null)
{
log7.LogInfo((object)("[MicRecovery] 已切换麦克风到首选设备：" + text2));
}
}
}
else if (PluginConfig.DebugEnabled)
{
ManualLogSource log8 = Plugin.Log;
if (log8 != null)
{
log8.LogInfo((object)("[MicRecovery] 当前已是首选设备：" + text2));
}
}
}
else
{
ManualLogSource log9 = Plugin.Log;
if (log9 != null)
{
log9.LogWarning((object)"[MicRecovery] 没找到可用的首选设备，将沿用当前设备继续恢复。");
}
}
val.ResetMicrophoneCapture();
_lastRecoveryTime = Time.unscaledTime;
GameSideResetResult gameSideResetResult = TryInvokeGameSideReset();
float num2 = ((PluginConfig.PostRecoveryGraceSeconds != null) ? Mathf.Max(0f, PluginConfig.PostRecoveryGraceSeconds.Value) : 4f);
_postRecoveryGraceUntil = Time.unscaledTime + num2;
switch (gameSideResetResult)
{
case GameSideResetResult.Invoked:
LogRecoveryStep(4, "已执行 ResetMicrophoneCapture，已启动游戏侧重置");
break;
case GameSideResetResult.SkippedUnsafe:
LogRecoveryStep(4, "已执行 ResetMicrophoneCapture，已跳过游戏侧重置（当前阶段不安全）");
break;
case GameSideResetResult.MethodNotFound:
LogRecoveryStep(4, "已执行 ResetMicrophoneCapture，未执行游戏侧重置（未找到重置方法）");
break;
default:
LogRecoveryStep(4, "已执行 ResetMicrophoneCapture，未执行游戏侧重置（调用失败）");
break;
}
LogRecoveryStep(5, $"麦克风恢复流程已触发，进入 {num2:0.##} 秒恢复宽限期，请立刻测试语音是否恢复");
return true;
}
catch (Exception arg)
{
ManualLogSource log10 = Plugin.Log;
if (log10 != null)
{
log10.LogError((object)"========== [麦克风修复 3/5] 恢复过程中出现异常 ==========");
}
ManualLogSource log11 = Plugin.Log;
if (log11 != null)
{
log11.LogError((object)$"========== [麦克风修复 4/5] 异常：{arg} ==========");
}
ManualLogSource log12 = Plugin.Log;
if (log12 != null)
{
log12.LogError((object)"========== [麦克风修复 5/5] 本次恢复失败，请把日志贴回来 ==========");
}
return false;
}
}
internal static bool IsMenuSceneActive()
{
//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)
try
{
Scene activeScene = SceneManager.GetActiveScene();
if (!((Scene)(ref activeScene)).IsValid())
{
return true;
}
return (((Scene)(ref activeScene)).name ?? string.Empty).IndexOf("menu", StringComparison.OrdinalIgnoreCase) >= 0;
}
catch
{
return true;
}
}
private static bool TryGetStartOfRoundInstance(out Type startOfRoundType, out object startOfRoundInstance)
{
startOfRoundType = Type.GetType("StartOfRound, Assembly-CSharp");
startOfRoundInstance = null;
if (startOfRoundType == null)
{
return false;
}
PropertyInfo property = startOfRoundType.GetProperty("Instance", StaticFlags);
if (property != null)
{
startOfRoundInstance = property.GetValue(null);
}
if (startOfRoundInstance == null)
{
FieldInfo field = startOfRoundType.GetField("Instance", StaticFlags);
if (field != null)
{
startOfRoundInstance = field.GetValue(null);
}
}
object obj = startOfRoundInstance;
Object val = (Object)((obj is Object) ? obj : null);
if (val != null && val == (Object)null)
{
startOfRoundInstance = null;
}
return startOfRoundInstance != null;
}
internal static bool IsStartOfRoundReady()
{
Type startOfRoundType;
object startOfRoundInstance;
return TryGetStartOfRoundInstance(out startOfRoundType, out startOfRoundInstance);
}
internal static bool IsGameSideResetSafe()
{
try
{
if (IsMenuSceneActive())
{
return false;
}
if (!TryGetStartOfRoundInstance(out var startOfRoundType, out var startOfRoundInstance))
{
return false;
}
FieldInfo field = startOfRoundType.GetField("localPlayerController", InstanceFlags);
if (field != null)
{
object value = field.GetValue(startOfRoundInstance);
if (value == null)
{
return false;
}
Object val = (Object)((value is Object) ? value : null);
if (val != null && val == (Object)null)
{
return false;
}
}
return true;
}
catch
{
return false;
}
}
private static void LogRecoveryStep(int step, string message)
{
if (PluginConfig.ShowFiveStepRecoveryLogs != null && PluginConfig.ShowFiveStepRecoveryLogs.Value)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogWarning((object)$"========== [麦克风修复 {step}/5] {message} ==========");
}
}
else if (PluginConfig.DebugEnabled)
{
ManualLogSource log2 = Plugin.Log;
if (log2 != null)
{
log2.LogInfo((object)$"[MicRecovery] Step {step}/5: {message}");
}
}
}
private static string PickPreferredDevice(string[] devices, string currentMicName)
{
if (devices == null || devices.Length == 0)
{
return null;
}
if (PluginConfig.PreferCurrentDeviceIfStillExists != null && PluginConfig.PreferCurrentDeviceIfStillExists.Value && !string.IsNullOrWhiteSpace(currentMicName) && devices.Any((string d) => string.Equals(d, currentMicName, StringComparison.Ordinal)))
{
return currentMicName;
}
string[] array = (from x in ((PluginConfig.PreferredDeviceKeywords != null) ? PluginConfig.PreferredDeviceKeywords.Value : "Maxwell,Audeze").Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries)
select x.Trim() into x
where !string.IsNullOrWhiteSpace(x)
select x).ToArray();
foreach (string keyword in array)
{
string text = devices.FirstOrDefault((string d) => !string.IsNullOrEmpty(d) && d.IndexOf(keyword, StringComparison.OrdinalIgnoreCase) >= 0);
if (!string.IsNullOrEmpty(text))
{
return text;
}
}
return devices.FirstOrDefault((string d) => !string.IsNullOrWhiteSpace(d));
}
private static GameSideResetResult TryInvokeGameSideReset()
{
try
{
if (!IsGameSideResetSafe())
{
if (PluginConfig.DebugEnabled)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogInfo((object)"[MicRecovery] 当前不适合调用游戏侧重置入口，已跳过 ResetDissonanceCommsComponent。");
}
}
return GameSideResetResult.SkippedUnsafe;
}
if (!TryGetStartOfRoundInstance(out var startOfRoundType, out var startOfRoundInstance))
{
LogGameSideResetCompatibilityWarningOnce("无法获取 StartOfRound 实例");
return GameSideResetResult.SkippedUnsafe;
}
MethodInfo method = startOfRoundType.GetMethod("ResetDissonanceCommsComponent", InstanceFlags);
if (method == null)
{
LogGameSideResetCompatibilityWarningOnce("未找到 ResetDissonanceCommsComponent 方法");
if (PluginConfig.DebugEnabled)
{
ManualLogSource log2 = Plugin.Log;
if (log2 != null)
{
log2.LogWarning((object)"[MicRecovery] 未找到 ResetDissonanceCommsComponent 方法。");
}
}
return GameSideResetResult.MethodNotFound;
}
if (method.Invoke(startOfRoundInstance, null) is IEnumerator routine && (Object)(object)Plugin.Instance != (Object)null)
{
((MonoBehaviour)Plugin.Instance).StartCoroutine(SafeRunGameSideResetCoroutine(routine));
}
return GameSideResetResult.Invoked;
}
catch (Exception ex)
{
if (PluginConfig.DebugEnabled)
{
ManualLogSource log3 = Plugin.Log;
if (log3 != null)
{
log3.LogWarning((object)("[MicRecovery] 调用游戏侧重置入口失败：" + ex.Message));
}
}
return GameSideResetResult.Failed;
}
}
private static void LogGameSideResetCompatibilityWarningOnce(string reason)
{
if (!_gameSideResetCompatibilityWarningLogged)
{
_gameSideResetCompatibilityWarningLogged = true;
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogWarning((object)("[MicRecovery] 游戏侧重置入口不可用（" + reason + "），已降级为仅执行本地 ResetMicrophoneCapture。"));
}
}
}
[IteratorStateMachine(typeof(<SafeRunGameSideResetCoroutine>d__19))]
private static IEnumerator SafeRunGameSideResetCoroutine(IEnumerator routine)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <SafeRunGameSideResetCoroutine>d__19(0)
{
routine = routine
};
}
}
}
