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 BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using HarmonyLib;
using Il2CppInterop.Runtime.InteropTypes;
using Microsoft.CodeAnalysis;
using P1.Sound;
using P1.System.Sound;
using P1.System.Sound.Rhythm;
using P2.Sound;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("PataponAudioFixes")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("PataponAudioFixes")]
[assembly: AssemblyTitle("PataponAudioFixes")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[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]
[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;
}
}
}
namespace PataponAudioFix
{
[HarmonyPatch(typeof(Rhythm), "playRhythm")]
internal static class P1RhythmPlayCountVirtualWrapFix
{
private static void Prefix(Rhythm __instance, PlayRequest rhythmPlayRequest, out PlayCountFixState __state)
{
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Expected O, but got Unknown
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Invalid comparison between Unknown and I4
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Invalid comparison between Unknown and I4
__state = new PlayCountFixState();
if (!Plugin.ThemeLoopFixEnabled)
{
return;
}
try
{
if (__instance != null && rhythmPlayRequest != null && (int)rhythmPlayRequest.rhythmMood == 2 && (int)__instance.lastMood_ == 2)
{
uint playCount_ = __instance.playCount_;
if (playCount_ > 16)
{
uint num = (playCount_ - 1) % 16 + 1;
__state.Applied = true;
__state.OriginalPlayCount = playCount_;
__state.VirtualPlayCount = num;
__instance.playCount_ = num;
}
}
}
catch (Exception ex)
{
ManualLogSource l = Plugin.L;
bool flag = default(bool);
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(24, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[P1 FIX] Prefix failed: ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
}
l.LogWarning(val);
}
}
private static void Postfix(Rhythm __instance, bool __result, PlayCountFixState __state)
{
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Expected O, but got Unknown
try
{
if (__instance != null && __state != null && __state.Applied)
{
__instance.playCount_ = (__result ? (__state.OriginalPlayCount + 1) : __state.OriginalPlayCount);
Plugin.D($"[P1 FIX] Virtualized Mood_High playCount {__state.OriginalPlayCount} -> {__state.VirtualPlayCount}, restored to {__instance.playCount_}");
}
}
catch (Exception ex)
{
ManualLogSource l = Plugin.L;
bool flag = default(bool);
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(25, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[P1 FIX] Postfix failed: ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
}
l.LogWarning(val);
}
}
}
internal static class P1HelperMidiState
{
public static BgmPlayer? HelperPlayer;
public static bool SequenceActive;
public static bool HelperFadedOut;
public static float CachedTargetVolume = 1f;
private static bool HasLastRhythmState;
private static Mood LastMood;
private static uint LastPlayCount;
private static bool LastIsPlay;
public static void Reset(string source)
{
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Expected O, but got Unknown
//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
try
{
if (HelperFadedOut && HelperPlayer != null)
{
HelperPlayer.setMute(0u);
Player? innerPlayer = GetInnerPlayer(HelperPlayer);
if (innerPlayer != null)
{
innerPlayer.setVolumeDirect(CachedTargetVolume);
}
Plugin.D($"[P1 HELPER MIDI] reset: inner restored to {CachedTargetVolume} from {source}");
}
}
catch (Exception ex)
{
ManualLogSource l = Plugin.L;
bool flag = default(bool);
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(52, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[P1 HELPER MIDI] reset restore-volume failed from ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(source);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
}
l.LogWarning(val);
}
SequenceActive = false;
HelperFadedOut = false;
HelperPlayer = null;
HasLastRhythmState = false;
LastMood = (Mood)0;
LastPlayCount = 0u;
LastIsPlay = false;
Plugin.D("[P1 HELPER MIDI] reset from " + source);
}
private static Player? GetInnerPlayer(BgmPlayer player)
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Expected O, but got Unknown
try
{
RhythmBgmPlayer obj = ((Il2CppObjectBase)player).TryCast<RhythmBgmPlayer>();
return (obj != null) ? obj.rhythm_ : null;
}
catch (Exception ex)
{
ManualLogSource l = Plugin.L;
bool flag = default(bool);
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(40, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[P1 HELPER MIDI] GetInnerPlayer failed: ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
}
l.LogWarning(val);
return null;
}
}
public static float ReadInnerVolume(BgmPlayer player)
{
Player innerPlayer = GetInnerPlayer(player);
if (innerPlayer == null)
{
return -1f;
}
return innerPlayer.getVolume();
}
public static void SetHelperVolume(bool fadedOut, string source, bool force = false)
{
//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
//IL_0201: Expected O, but got Unknown
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Expected O, but got Unknown
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Expected O, but got Unknown
bool flag = default(bool);
try
{
if (!force && HelperFadedOut == fadedOut)
{
return;
}
BgmPlayer helperPlayer = HelperPlayer;
if (helperPlayer == null)
{
ManualLogSource l = Plugin.L;
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(65, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[P1 HELPER MIDI] wanted fadedOut=");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<bool>(fadedOut);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" from ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(source);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(", but helperPlayer is null");
}
l.LogWarning(val);
HelperFadedOut = fadedOut;
return;
}
Player innerPlayer = GetInnerPlayer(helperPlayer);
if (innerPlayer == null)
{
ManualLogSource l2 = Plugin.L;
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(75, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[P1 HELPER MIDI] inner rhythm Player is null from ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(source);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("; falling back to setMute");
}
l2.LogWarning(val);
helperPlayer.setMute(fadedOut ? uint.MaxValue : 0u);
HelperFadedOut = fadedOut;
return;
}
if (fadedOut)
{
innerPlayer.setVolumeDirect(0f);
Plugin.D($"[P1 HELPER MIDI] INNER-ZERO from {source}, innerVol={innerPlayer.getVolume()}, rid={helperPlayer.getRID()}, isPlay={helperPlayer.isPlay()}");
}
else
{
innerPlayer.setVolumeDirect(CachedTargetVolume);
Plugin.D($"[P1 HELPER MIDI] INNER-FULL vol={CachedTargetVolume} from {source}, innerVol={innerPlayer.getVolume()}, rid={helperPlayer.getRID()}, isPlay={helperPlayer.isPlay()}");
}
HelperFadedOut = fadedOut;
}
catch (Exception ex)
{
ManualLogSource l3 = Plugin.L;
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(58, 3, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[P1 HELPER MIDI] SetHelperVolume(fadedOut=");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<bool>(fadedOut);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(") failed from ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(source);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
}
l3.LogWarning(val);
}
}
public static void ResetProgress(string source)
{
SequenceActive = false;
SetHelperVolume(fadedOut: false, source, force: true);
Plugin.D("[P1 HELPER MIDI] progress reset from " + source);
}
public static void OnSuccessfulRhythm(Rhythm rhythm, PlayRequest request)
{
}
public static void WatchRhythmState(Rhythm rhythm)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
//IL_01e4: Expected O, but got Unknown
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: 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_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
//IL_01be: Unknown result type (might be due to invalid IL or missing references)
//IL_0145: Unknown result type (might be due to invalid IL or missing references)
//IL_0196: Unknown result type (might be due to invalid IL or missing references)
try
{
Mood lastMood_ = rhythm.lastMood_;
uint playCount_ = rhythm.playCount_;
bool isPlay_ = rhythm.isPlay_;
if (!HasLastRhythmState)
{
HasLastRhythmState = true;
LastMood = lastMood_;
LastPlayCount = playCount_;
LastIsPlay = isPlay_;
return;
}
if (lastMood_ != LastMood || playCount_ != LastPlayCount || isPlay_ != LastIsPlay)
{
Plugin.D($"[P1 RHYTHM TRANS] mood={LastMood}->{lastMood_}, playCount={LastPlayCount}->{playCount_}, isPlay={LastIsPlay}->{isPlay_}, seqActive={SequenceActive}, fadedOut={HelperFadedOut}");
}
if (isPlay_ && !LastIsPlay)
{
SequenceActive = true;
SetHelperVolume(fadedOut: true, $"chant begin (isPlay->True) mood={lastMood_}, playCount={playCount_}");
}
else if (!isPlay_ && LastIsPlay)
{
SequenceActive = false;
SetHelperVolume(fadedOut: false, $"input window (isPlay->False) mood={lastMood_}, playCount={playCount_}");
}
LastMood = lastMood_;
LastPlayCount = playCount_;
LastIsPlay = isPlay_;
}
catch (Exception ex)
{
ManualLogSource l = Plugin.L;
bool flag = default(bool);
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(42, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[P1 HELPER MIDI] WatchRhythmState failed: ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
}
l.LogWarning(val);
}
}
}
[HarmonyPatch(typeof(Director), "playMidi")]
internal static class P1CaptureHelperMidiPlayer
{
private static void Postfix(Director __instance, int midiIndex, MixingCategory cate, float fadeTime)
{
//IL_0165: Unknown result type (might be due to invalid IL or missing references)
//IL_016c: Expected O, but got Unknown
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Invalid comparison between Unknown and I4
if (!Plugin.HelperMuteEnabled)
{
return;
}
try
{
if (!P1HelperMidiState.SequenceActive && midiIndex == 0 && (int)cate == 3)
{
P1HelperMidiState.Reset("playMidi(0, BGM)");
}
else
{
if (midiIndex != 0 || (int)cate != 4)
{
return;
}
BgmPlayer curPlayer_ = __instance.curPlayer_;
if (curPlayer_ == null)
{
Plugin.L.LogWarning((object)"[P1 HELPER MIDI] wanted to capture helper player, but curPlayer_ is null");
return;
}
bool value = P1HelperMidiState.HelperPlayer != null;
P1HelperMidiState.HelperPlayer = curPlayer_;
float num = -1f;
if (!P1HelperMidiState.HelperFadedOut)
{
num = P1HelperMidiState.ReadInnerVolume(curPlayer_);
if (num > 0f)
{
P1HelperMidiState.CachedTargetVolume = num;
}
}
Plugin.D($"[P1 HELPER MIDI] CAPTURED helper from playMidi(0, Rhythm), hadCachedPlayer={value}, playId={curPlayer_.playId_}, rid={curPlayer_.getRID()}, innerVol={num}, cachedTarget={P1HelperMidiState.CachedTargetVolume}, isPlay={curPlayer_.isPlay()}, sequenceActive={P1HelperMidiState.SequenceActive}");
if (P1HelperMidiState.SequenceActive && P1HelperMidiState.HelperFadedOut)
{
P1HelperMidiState.SetHelperVolume(fadedOut: true, "re-applied fade after playMidi(0, Rhythm) recapture", force: true);
}
}
}
catch (Exception ex)
{
ManualLogSource l = Plugin.L;
bool flag = default(bool);
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(33, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[P1 HELPER MIDI] capture failed: ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
}
l.LogWarning(val);
}
}
}
[HarmonyPatch(typeof(Rhythm), "playRhythm")]
internal static class P1HelperOnSuccessfulRhythm
{
private static void Postfix(Rhythm __instance, PlayRequest rhythmPlayRequest, bool __result)
{
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
if (Plugin.HelperMuteEnabled && __instance != null && rhythmPlayRequest != null)
{
Plugin.D($"[P1 EVENT] playRhythm result={__result}, mood={rhythmPlayRequest.rhythmMood}, lastMood={__instance.lastMood_}, playCount={__instance.playCount_}, playSEIndex={__instance.playSEIndex_}, isPlay={__instance.isPlay_}, seqActive={P1HelperMidiState.SequenceActive}");
if (__result)
{
P1HelperMidiState.OnSuccessfulRhythm(__instance, rhythmPlayRequest);
}
}
}
}
[HarmonyPatch(typeof(Rhythm), "update")]
internal static class P1HelperWatchRhythmState
{
private static void Postfix(Rhythm __instance)
{
if (Plugin.HelperMuteEnabled && __instance != null)
{
P1HelperMidiState.WatchRhythmState(__instance);
}
}
}
[HarmonyPatch(typeof(Rhythm), "clearPlayCount")]
internal static class P1HelperResetOnClearPlayCount
{
private static void Postfix()
{
Plugin.D($"[P1 EVENT] Rhythm.clearPlayCount fired, seqActive={P1HelperMidiState.SequenceActive}, fadedOut={P1HelperMidiState.HelperFadedOut}");
if (Plugin.HelperMuteEnabled && (P1HelperMidiState.SequenceActive || P1HelperMidiState.HelperFadedOut))
{
P1HelperMidiState.ResetProgress("Rhythm.clearPlayCount");
}
}
}
[HarmonyPatch(typeof(Rhythm), "resetPlayCount")]
internal static class P1HelperResetOnResetPlayCount
{
private static void Postfix()
{
Plugin.D($"[P1 EVENT] Rhythm.resetPlayCount fired, seqActive={P1HelperMidiState.SequenceActive}, fadedOut={P1HelperMidiState.HelperFadedOut}");
if (Plugin.HelperMuteEnabled && (P1HelperMidiState.SequenceActive || P1HelperMidiState.HelperFadedOut))
{
P1HelperMidiState.ResetProgress("Rhythm.resetPlayCount");
}
}
}
[HarmonyPatch(typeof(Director), "moodDown")]
internal static class P1HelperResetOnMoodDown
{
private static void Postfix()
{
Plugin.D($"[P1 EVENT] Director.moodDown fired, seqActive={P1HelperMidiState.SequenceActive}, fadedOut={P1HelperMidiState.HelperFadedOut}");
if (Plugin.HelperMuteEnabled && (P1HelperMidiState.SequenceActive || P1HelperMidiState.HelperFadedOut))
{
P1HelperMidiState.ResetProgress("Director.moodDown");
}
}
}
[HarmonyPatch(typeof(Director), "startPlayGame")]
internal static class P1HelperResetOnStartPlayGame
{
private static void Prefix()
{
if (Plugin.HelperMuteEnabled)
{
P1HelperMidiState.Reset("Director.startPlayGame");
}
}
}
[HarmonyPatch(typeof(Director), "exitPlayGame")]
internal static class P1HelperResetOnExitPlayGame
{
private static void Prefix()
{
if (Plugin.HelperMuteEnabled)
{
P1HelperMidiState.Reset("Director.exitPlayGame");
}
}
}
[HarmonyPatch(typeof(Rhythm), "playRhythm")]
internal static class P2RhythmPlayCountVirtualWrapFix
{
private static void Prefix(Rhythm __instance, out PlayCountFixState __state)
{
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Expected O, but got Unknown
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Invalid comparison between Unknown and I4
__state = new PlayCountFixState();
if (!Plugin.ThemeLoopFixEnabled)
{
return;
}
try
{
if (__instance != null && (int)__instance.lastMood_ == 2)
{
uint playCount_ = __instance.playCount_;
if (playCount_ > 16)
{
uint num = (playCount_ - 1) % 16 + 1;
__state.Applied = true;
__state.OriginalPlayCount = playCount_;
__state.VirtualPlayCount = num;
__instance.playCount_ = num;
}
}
}
catch (Exception ex)
{
ManualLogSource l = Plugin.L;
bool flag = default(bool);
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(24, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[P2 FIX] Prefix failed: ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
}
l.LogWarning(val);
}
}
private static void Postfix(Rhythm __instance, bool __result, PlayCountFixState __state)
{
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Expected O, but got Unknown
try
{
if (__instance != null && __state != null && __state.Applied)
{
__instance.playCount_ = (__result ? (__state.OriginalPlayCount + 1) : __state.OriginalPlayCount);
Plugin.D($"[P2 FIX] Virtualized Mood_High playCount {__state.OriginalPlayCount} -> {__state.VirtualPlayCount}, restored to {__instance.playCount_}");
}
}
catch (Exception ex)
{
ManualLogSource l = Plugin.L;
bool flag = default(bool);
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(25, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[P2 FIX] Postfix failed: ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
}
l.LogWarning(val);
}
}
}
[HarmonyPatch(typeof(BeatCommander), "update")]
internal static class P2HelperFadeController
{
private const float KaesiBeat = 4f;
private static int WarnCount;
private static float CurVol = 1f;
private static bool Applying;
private static readonly Stopwatch Clock = Stopwatch.StartNew();
private static long LastMs;
private static float LastBeat;
private static bool HasLastBeat;
private static float MsPerBeat = 500f;
private static void SetCategoryVolume(float vol)
{
CriSoundManager instance = SingletonMonobehaviour<CriSoundManager>.Instance;
if (!((Object)(object)instance == (Object)null))
{
instance.setCategorySetVolume((MixingCategory)Plugin.P2HelperCategory, vol, 0f);
}
}
private static void Postfix(BeatCommander __instance)
{
//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
//IL_01b1: Expected O, but got Unknown
//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
//IL_00be: Invalid comparison between Unknown and I4
if (!Plugin.HelperMuteEnabled || __instance == null)
{
return;
}
try
{
float p2FadeMs = Plugin.P2FadeMs;
float p2FullVolume = Plugin.P2FullVolume;
long elapsedMilliseconds = Clock.ElapsedMilliseconds;
float num = ((LastMs == 0L) ? 16f : Math.Min(p2FadeMs, elapsedMilliseconds - LastMs));
LastMs = elapsedMilliseconds;
float commandBeatCount = __instance.getCommandBeatCount();
if (HasLastBeat)
{
float num2 = commandBeatCount - LastBeat;
if (num2 > 0.0001f && num2 < 2f && num > 0f)
{
float num3 = num / num2;
if (num3 > 50f && num3 < 5000f)
{
MsPerBeat = MsPerBeat * 0.9f + num3 * 0.1f;
}
}
}
LastBeat = commandBeatCount;
HasLastBeat = true;
bool num4 = (int)__instance.getState() == 3;
float num5 = ((MsPerBeat > 0f) ? (Plugin.P2FadeLeadMs / MsPerBeat) : 0f);
bool flag = !num4 && commandBeatCount < 4f && commandBeatCount >= 4f - num5;
float num6 = ((num4 || flag) ? 0f : p2FullVolume);
float num7 = p2FullVolume * (num / p2FadeMs);
if (CurVol < num6)
{
CurVol = Math.Min(num6, CurVol + num7);
}
else if (CurVol > num6)
{
CurVol = Math.Max(num6, CurVol - num7);
}
if (num4 || CurVol < p2FullVolume - 0.001f)
{
SetCategoryVolume(CurVol);
Applying = true;
}
else if (Applying)
{
SetCategoryVolume(p2FullVolume);
Applying = false;
}
}
catch (Exception ex)
{
if (WarnCount < 3)
{
WarnCount++;
ManualLogSource l = Plugin.L;
bool flag2 = default(bool);
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(35, 2, ref flag2);
if (flag2)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[P2 HELPER] controller failed (#");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(WarnCount);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("): ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
}
l.LogWarning(val);
}
}
}
}
[BepInPlugin("juras.patapon.audiofix", "Music Fixes Extended", "2.0.0")]
public class Plugin : BasePlugin
{
internal static ManualLogSource L;
internal static ConfigEntry<uint> AudioFix_ThemeLoopFix;
internal static ConfigEntry<uint> AudioFix_HelperMute;
internal static ConfigEntry<uint> AudioFix_P2HelperCategory;
internal static ConfigEntry<uint> AudioFix_P2FadeMs;
internal static ConfigEntry<uint> AudioFix_P2FadeLeadMs;
internal static ConfigEntry<uint> AudioFix_P2FullVolumePercent;
internal const bool DebugLog = false;
internal static bool ThemeLoopFixEnabled => AudioFix_ThemeLoopFix.Value != 0;
internal static bool HelperMuteEnabled => AudioFix_HelperMute.Value != 0;
internal static uint P2HelperCategory => AudioFix_P2HelperCategory.Value;
internal static float P2FadeMs
{
get
{
if (AudioFix_P2FadeMs.Value >= 1)
{
return AudioFix_P2FadeMs.Value;
}
return 1f;
}
}
internal static float P2FadeLeadMs => AudioFix_P2FadeLeadMs.Value;
internal static float P2FullVolume
{
get
{
uint num = AudioFix_P2FullVolumePercent.Value;
if (num > 100)
{
num = 100u;
}
return (float)num / 100f;
}
}
internal static void D(string message)
{
}
public override void Load()
{
//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
//IL_00f3: Expected O, but got Unknown
//IL_012a: Unknown result type (might be due to invalid IL or missing references)
//IL_0130: Expected O, but got Unknown
//IL_0162: Unknown result type (might be due to invalid IL or missing references)
L = ((BasePlugin)this).Log;
AudioFix_ThemeLoopFix = ((BasePlugin)this).Config.Bind<uint>("AudioFix", "AudioFix_ThemeLoopFix", 1u, "Set to 1 to enable the rhythm/theme loop playCount fix. Set to 0 to disable it.");
AudioFix_HelperMute = ((BasePlugin)this).Config.Bind<uint>("AudioFix", "AudioFix_HelperMute", 1u, "Set to 1 to enable helper mute/fade behavior. Set to 0 to disable it.");
AudioFix_P2HelperCategory = ((BasePlugin)this).Config.Bind<uint>("AudioFix_P2", "AudioFix_P2HelperCategory", 3u, "P2 only: CriSoundManager mixing category that carries the helper (3 = BGM). Only change if a game update moves the helper to a different category.");
AudioFix_P2FadeMs = ((BasePlugin)this).Config.Bind<uint>("AudioFix_P2", "AudioFix_P2FadeMs", 400u, "P2 only: helper fade duration in milliseconds at the start/end of the chant phase. Higher = more gradual.");
AudioFix_P2FadeLeadMs = ((BasePlugin)this).Config.Bind<uint>("AudioFix_P2", "AudioFix_P2FadeLeadMs", 250u, "P2 only: how many milliseconds BEFORE the chant the fade-out begins (anticipation). 0 = start exactly at the chant. Tempo-adaptive (stays constant during Fever).");
AudioFix_P2FullVolumePercent = ((BasePlugin)this).Config.Bind<uint>("AudioFix_P2", "AudioFix_P2FullVolumePercent", 70u, "P2 only: the helper's full (un-ducked) volume as a percent (0-100). Lower it if the helper jumps louder at the chant start; raise it if the helper is too quiet while drumming.");
L.LogInfo((object)"Music Fixes Extended 2.0.0 loaded");
ManualLogSource l = L;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(23, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AudioFix_ThemeLoopFix: ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ThemeLoopFixEnabled ? "enabled" : "disabled");
}
l.LogInfo(val);
ManualLogSource l2 = L;
val = new BepInExInfoLogInterpolatedStringHandler(21, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AudioFix_HelperMute: ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(HelperMuteEnabled ? "enabled" : "disabled");
}
l2.LogInfo(val);
new Harmony("juras.patapon.audiofix").PatchAll();
}
}
internal sealed class PlayCountFixState
{
public bool Applied;
public uint OriginalPlayCount;
public uint VirtualPlayCount;
}
}
