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 Microsoft.CodeAnalysis;
using P1.Sound;
using P1.System.Sound;
using P2.Media.Lrt;
using P2.Sound;
using P2.System.Sound;
[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]
[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 PataponAudioFix
{
[BepInPlugin("juras.patapon.audiofix", "Patapon Audio Fix", "1.0.0")]
public class Plugin : BasePlugin
{
internal static ManualLogSource L;
internal static ConfigEntry<uint> AudioFix_ThemeLoopFix;
internal static ConfigEntry<uint> AudioFix_HelperMute;
internal const bool DebugLog = false;
internal static bool ThemeLoopFixEnabled => AudioFix_ThemeLoopFix.Value != 0;
internal static bool HelperMuteEnabled => AudioFix_HelperMute.Value != 0;
internal static void D(string message)
{
}
internal static void DW(string message)
{
}
public override void Load()
{
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Expected O, but got Unknown
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: Expected O, but got Unknown
//IL_00d9: 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 behavior. Set to 0 to disable it.");
L.LogInfo((object)"Patapon Audio Fix 1.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;
}
[HarmonyPatch(typeof(Rhythm), "playRhythm")]
internal static class P1RhythmPlayCountVirtualWrapFix
{
private static void Prefix(Rhythm __instance, PlayRequest rhythmPlayRequest, out PlayCountFixState __state)
{
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: Expected O, but got Unknown
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Invalid comparison between Unknown and I4
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: 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);
}
}
}
[HarmonyPatch(typeof(Rhythm), "playRhythm")]
internal static class P2RhythmPlayCountVirtualWrapFix
{
private static void Prefix(Rhythm __instance, out PlayCountFixState __state)
{
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_0069: Expected O, but got Unknown
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: 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);
}
}
}
internal static class P1HelperMidiState
{
public static BgmPlayer? HelperPlayer;
public static bool SequenceActive;
public static bool HelperMuted;
private static bool HasLastRhythmState;
private static Mood LastMood;
private static uint LastPlayCount;
private static bool LastIsPlay;
public const uint HelperMuteMask = uint.MaxValue;
public static void Reset(string source)
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Expected O, but got Unknown
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
try
{
if (HelperMuted && HelperPlayer != null)
{
HelperPlayer.setMute(0u);
}
}
catch (Exception ex)
{
ManualLogSource l = Plugin.L;
bool flag = default(bool);
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(44, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[P1 HELPER MIDI] reset unmute failed from ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(source);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
}
l.LogWarning(val);
}
SequenceActive = false;
HelperMuted = false;
HelperPlayer = null;
HasLastRhythmState = false;
LastMood = (Mood)0;
LastPlayCount = 0u;
LastIsPlay = false;
Plugin.D("[P1 HELPER MIDI] reset from " + source);
}
public static void SetHelperMuted(bool muted, string source, bool force = false)
{
//IL_012f: Unknown result type (might be due to invalid IL or missing references)
//IL_0135: 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
bool flag = default(bool);
try
{
if (!force && HelperMuted == muted)
{
return;
}
BgmPlayer helperPlayer = HelperPlayer;
if (helperPlayer == null)
{
ManualLogSource l = Plugin.L;
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(62, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[P1 HELPER MIDI] wanted muted=");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<bool>(muted);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" from ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(source);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(", but helperPlayer is null");
}
l.LogWarning(val);
HelperMuted = muted;
}
else
{
helperPlayer.setMute(muted ? uint.MaxValue : 0u);
HelperMuted = muted;
Plugin.D($"[P1 HELPER MIDI] {(muted ? "MUTED" : "UNMUTED")} helper from {source}, playId={helperPlayer.playId_}, rid={helperPlayer.getRID()}, isPlay={helperPlayer.isPlay()}");
}
}
catch (Exception ex)
{
ManualLogSource l2 = Plugin.L;
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(48, 3, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[P1 HELPER MIDI] SetHelperMuted(");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<bool>(muted);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(") failed from ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(source);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
}
l2.LogWarning(val);
}
}
public static void ResetProgress(string source)
{
SequenceActive = false;
SetHelperMuted(muted: false, source, force: true);
Plugin.D("[P1 HELPER MIDI] progress reset from " + source);
}
public static void OnSuccessfulRhythm(Rhythm rhythm, PlayRequest request)
{
//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Expected O, but got Unknown
//IL_0029: 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)
try
{
if (!SequenceActive)
{
SequenceActive = true;
SetHelperMuted(muted: true, $"first successful command mood={request.rhythmMood}, playCount={rhythm.playCount_}");
Plugin.D($"[P1 HELPER MIDI] sequence started; helper muted immediately: mood={request.rhythmMood}, playCount={rhythm.playCount_}, playSEIndex={rhythm.playSEIndex_}");
}
}
catch (Exception ex)
{
ManualLogSource l = Plugin.L;
bool flag = default(bool);
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(44, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[P1 HELPER MIDI] OnSuccessfulRhythm failed: ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
}
l.LogWarning(val);
}
}
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_015e: Unknown result type (might be due to invalid IL or missing references)
//IL_0165: Expected O, but got Unknown
//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_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
//IL_013e: Unknown result type (might be due to invalid IL or missing references)
//IL_013f: Unknown result type (might be due to invalid IL or missing references)
//IL_0107: Unknown result type (might be due to invalid IL or missing references)
//IL_0109: Invalid comparison between Unknown and I4
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 (SequenceActive && LastPlayCount != 0 && playCount_ == 0 && !isPlay_)
{
Plugin.D($"[P1 HELPER MIDI] rhythm loss detected: mood {LastMood}->{lastMood_}, playCount {LastPlayCount}->0, isPlay {LastIsPlay}->{isPlay_}");
ResetProgress("rhythm loss");
}
else if (!HelperMuted && (int)lastMood_ == 2 && playCount_ != 0 && !isPlay_)
{
SetHelperMuted(muted: true, $"after Mood_High transition finished, 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_0188: Unknown result type (might be due to invalid IL or missing references)
//IL_018f: Expected O, but got Unknown
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: 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_;
Plugin.D($"[P1 HELPER MIDI] CAPTURED helper player from playMidi(0, Rhythm), hadCachedPlayer={value}, playId={curPlayer_.playId_}, rid={curPlayer_.getRID()}, vol={curPlayer_.getVolumeValue()}, targetVol={curPlayer_.getTargetVolume()}, isPlay={curPlayer_.isPlay()}, sequenceActive={P1HelperMidiState.SequenceActive}, ");
if (P1HelperMidiState.SequenceActive && P1HelperMidiState.HelperMuted)
{
P1HelperMidiState.SetHelperMuted(muted: true, "re-applied mute 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)
{
if (Plugin.HelperMuteEnabled && __result && __instance != null && rhythmPlayRequest != null)
{
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()
{
if (Plugin.HelperMuteEnabled && (P1HelperMidiState.SequenceActive || P1HelperMidiState.HelperMuted))
{
P1HelperMidiState.ResetProgress("Rhythm.clearPlayCount");
}
}
}
[HarmonyPatch(typeof(Rhythm), "resetPlayCount")]
internal static class P1HelperResetOnResetPlayCount
{
private static void Postfix()
{
if (Plugin.HelperMuteEnabled && (P1HelperMidiState.SequenceActive || P1HelperMidiState.HelperMuted))
{
P1HelperMidiState.ResetProgress("Rhythm.clearPlayCount");
}
}
}
[HarmonyPatch(typeof(Director), "moodDown")]
internal static class P1HelperResetOnMoodDown
{
private static void Postfix()
{
if (Plugin.HelperMuteEnabled && (P1HelperMidiState.SequenceActive || P1HelperMidiState.HelperMuted))
{
P1HelperMidiState.ResetProgress("Rhythm.clearPlayCount");
}
}
}
[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");
}
}
}
internal static class P2HelperMidiState
{
public static bool CommandsStarted;
public static bool HelperMuted;
public static RhythmBgmPlayer? HelperPlayer;
public static Rhythm? RhythmInstance;
private static bool HasLastRhythmState;
private static Mood LastMood;
private static uint LastPlayCount;
public const uint HelperMuteMask = uint.MaxValue;
public static bool BattleActive;
public static void Reset(string source, bool forceLog = false)
{
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Expected O, but got Unknown
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
if (!BattleActive && !CommandsStarted && !HelperMuted && HelperPlayer == null && !HasLastRhythmState && !forceLog)
{
return;
}
try
{
if (HelperMuted && HelperPlayer != null)
{
((BgmPlayer)HelperPlayer).setMute(0u);
Plugin.D("[P2 HELPER MIDI] UNMUTED helper during reset from " + source);
}
}
catch (Exception ex)
{
ManualLogSource l = Plugin.L;
bool flag = default(bool);
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(44, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[P2 HELPER MIDI] reset unmute failed from ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(source);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
}
l.LogWarning(val);
}
BattleActive = false;
CommandsStarted = false;
HelperMuted = false;
HelperPlayer = null;
RhythmInstance = null;
HasLastRhythmState = false;
LastMood = (Mood)0;
LastPlayCount = 0u;
Plugin.D("[P2 HELPER MIDI] reset from " + source);
}
public static void CaptureHelperCandidate(RhythmBgmPlayer player, string source, BgmType type, MixingCategory cate, SubGameType subGameType, string detail)
{
//IL_0261: Unknown result type (might be due to invalid IL or missing references)
//IL_0268: Expected O, but got Unknown
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: 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_0189: Unknown result type (might be due to invalid IL or missing references)
//IL_018b: Invalid comparison between Unknown and I4
//IL_018d: Unknown result type (might be due to invalid IL or missing references)
//IL_0190: Invalid comparison between Unknown and I4
//IL_0193: Unknown result type (might be due to invalid IL or missing references)
//IL_0195: Invalid comparison between Unknown and I4
//IL_0197: Unknown result type (might be due to invalid IL or missing references)
//IL_0199: Invalid comparison between Unknown and I4
//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
//IL_0211: Unknown result type (might be due to invalid IL or missing references)
try
{
if (player == null)
{
return;
}
Plugin.D($"[P2 HELPER MIDI] addMidi candidate from {source}: type={type}, cate={cate}, subGameType={subGameType}, {detail}, playId={((BgmPlayer)player).playId_}, rid={((BgmPlayer)player).getRID()}, vol={((BgmPlayer)player).getVolumeValue()}, targetVol={((BgmPlayer)player).getTargetVolume()}, isPlay={((BgmPlayer)player).isPlay()}, isLoop={((BgmPlayer)player).isLoop()}, commandsStarted={CommandsStarted}, helperMuted={HelperMuted}");
bool num = (int)type == 1;
bool flag = (int)subGameType == 0;
bool flag2 = (int)cate == 3 || (int)cate == 4;
if (num && flag && flag2)
{
HelperPlayer = player;
Plugin.D($"[P2 HELPER MIDI] CAPTURED helper candidate from {source}, type={type}, cate={cate}, subGameType={subGameType}, {detail}");
if (CommandsStarted && !HelperMuted)
{
SetHelperMuted(muted: true, "late helper capture after commands already started");
}
}
}
catch (Exception ex)
{
ManualLogSource l = Plugin.L;
bool flag3 = default(bool);
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(54, 2, ref flag3);
if (flag3)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[P2 HELPER MIDI] CaptureHelperCandidate failed from ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(source);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
}
l.LogWarning(val);
}
}
public static void ResetProgress(string source)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
SetHelperMuted(muted: false, source, force: true);
CommandsStarted = false;
HasLastRhythmState = false;
LastMood = (Mood)0;
LastPlayCount = 0u;
Plugin.D("[P2 HELPER MIDI] progress reset from " + source);
}
public static void SetHelperMuted(bool muted, string source, bool force = false)
{
//IL_0143: Unknown result type (might be due to invalid IL or missing references)
//IL_0149: 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
bool flag = default(bool);
try
{
if (!force && HelperMuted == muted)
{
return;
}
RhythmBgmPlayer helperPlayer = HelperPlayer;
if (helperPlayer == null)
{
ManualLogSource l = Plugin.L;
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(62, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[P2 HELPER MIDI] wanted muted=");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<bool>(muted);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" from ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(source);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(", but helperPlayer is null");
}
l.LogWarning(val);
if (muted)
{
CommandsStarted = false;
}
else
{
HelperMuted = false;
}
return;
}
((BgmPlayer)helperPlayer).setMute(muted ? uint.MaxValue : 0u);
HelperMuted = muted;
if (!muted)
{
CommandsStarted = false;
}
Plugin.D($"[P2 HELPER MIDI] {(muted ? "MUTED" : "UNMUTED")} helper from {source}, playId={((BgmPlayer)helperPlayer).playId_}, rid={((BgmPlayer)helperPlayer).getRID()}, isPlay={((BgmPlayer)helperPlayer).isPlay()}");
}
catch (Exception ex)
{
ManualLogSource l2 = Plugin.L;
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(48, 3, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[P2 HELPER MIDI] SetHelperMuted(");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<bool>(muted);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(") failed from ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(source);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
}
l2.LogWarning(val);
}
}
public static void OnSuccessfulRhythm(Rhythm rhythm)
{
//IL_0158: Unknown result type (might be due to invalid IL or missing references)
//IL_015e: Expected O, but got Unknown
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
try
{
if (rhythm != null)
{
RhythmInstance = rhythm;
if (rhythm.playCount_ == 0 || rhythm.playSEIndex_ == 0)
{
Plugin.D($"[P2 HELPER MIDI] ignored early/empty playRhythm: mood={rhythm.lastMood_}, playCount={rhythm.playCount_}, playSEIndex={rhythm.playSEIndex_}");
}
else if (!CommandsStarted)
{
CommandsStarted = true;
Plugin.D($"[P2 HELPER MIDI] Commands started at mood={rhythm.lastMood_}, playCount={rhythm.playCount_}, playSEIndex={rhythm.playSEIndex_}, helperPlayer={((HelperPlayer == null) ? "null" : "cached")}");
SetHelperMuted(muted: true, "first successful playRhythm");
}
}
}
catch (Exception ex)
{
ManualLogSource l = Plugin.L;
bool flag = default(bool);
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(44, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[P2 HELPER MIDI] OnSuccessfulRhythm failed: ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
}
l.LogWarning(val);
}
}
public static void CheckForRhythmLoss(Rhythm rhythm)
{
//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
//IL_0102: Expected O, but got Unknown
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: 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_0024: 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)
//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
try
{
if (rhythm == null)
{
return;
}
Mood lastMood_ = rhythm.lastMood_;
uint playCount_ = rhythm.playCount_;
if (!HasLastRhythmState)
{
HasLastRhythmState = true;
LastMood = lastMood_;
LastPlayCount = playCount_;
return;
}
if (CommandsStarted && LastPlayCount != 0 && playCount_ == 0)
{
Plugin.D($"[P2 HELPER MIDI] rhythm loss detected by Rhythm.update: mood {LastMood}->{lastMood_}, playCount {LastPlayCount}->0, helperMuted={HelperMuted}");
ResetProgress("Rhythm.update loss");
}
LastMood = lastMood_;
LastPlayCount = playCount_;
}
catch (Exception ex)
{
ManualLogSource l = Plugin.L;
bool flag = default(bool);
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(44, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[P2 HELPER MIDI] CheckForRhythmLoss failed: ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
}
l.LogWarning(val);
}
}
public static void CheckLowLowMoodLoss(string source, int commandPoint, float commandBeatCount)
{
//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
//IL_01d4: Expected O, but got Unknown
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_0165: Unknown result type (might be due to invalid IL or missing references)
try
{
if (!CommandsStarted && !HelperMuted)
{
return;
}
Rhythm rhythmInstance = RhythmInstance;
if (rhythmInstance == null)
{
Plugin.D($"[P2 HELPER MIDI] low->low mood pulse, but RhythmInstance is null, commandPoint={commandPoint}, commandBeatCount={commandBeatCount}");
return;
}
Mood lastMood_ = rhythmInstance.lastMood_;
uint playCount_ = rhythmInstance.playCount_;
uint playSEIndex_ = rhythmInstance.playSEIndex_;
bool flag = playCount_ == 0;
Plugin.D($"[P2 HELPER MIDI] low->low mood pulse while active: rhythmMood={lastMood_}, playCount={playCount_}, playSEIndex={playSEIndex_}, commandPoint={commandPoint}, commandBeatCount={commandBeatCount}, looksLikeLoss={flag}");
if (flag)
{
ResetProgress($"{source}, rhythmMood={lastMood_}, playCount={playCount_}, commandPoint={commandPoint}, commandBeatCount={commandBeatCount}");
}
}
catch (Exception ex)
{
ManualLogSource l = Plugin.L;
bool flag2 = default(bool);
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(51, 2, ref flag2);
if (flag2)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[P2 HELPER MIDI] CheckLowLowMoodLoss failed from ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(source);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
}
l.LogWarning(val);
}
}
}
[HarmonyPatch(typeof(Director), "playMidi")]
internal static class P2TraceHelperMidiPlayMidi
{
private static void Postfix(Director __instance, int midiIndex, MixingCategory cate, float fadeTime)
{
//IL_0181: Unknown result type (might be due to invalid IL or missing references)
//IL_0187: Expected O, but got Unknown
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0139: Unknown result type (might be due to invalid IL or missing references)
//IL_013c: Invalid comparison between Unknown and I4
//IL_0155: Unknown result type (might be due to invalid IL or missing references)
if (!Plugin.HelperMuteEnabled)
{
return;
}
try
{
Plugin.D($"[P2 PLAYERTRACE] after playMidi argIndex={midiIndex}, argCate={cate}, curMIDIIndex={__instance.curMIDIIndex_}, curCate={__instance.curMidiCategory_}, bgmPlayers={((__instance.bgmPlayer_ == null) ? "null" : "not-null")}, commandsStarted={P2HelperMidiState.CommandsStarted}, helperMuted={P2HelperMidiState.HelperMuted}, helperPlayer={((P2HelperMidiState.HelperPlayer == null) ? "null" : "cached")}");
if (!P2HelperMidiState.BattleActive && !P2HelperMidiState.CommandsStarted && midiIndex == 0 && (int)cate == 11)
{
P2HelperMidiState.Reset($"playMidi(0, {cate})");
}
}
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 PLAYERTRACE] failed: ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
}
l.LogWarning(val);
}
}
}
[HarmonyPatch(typeof(Rhythm), "playRhythm")]
internal static class P2HelperOnSuccessfulRhythm
{
private static void Postfix(Rhythm __instance, bool __result)
{
if (Plugin.HelperMuteEnabled && __result && __instance != null)
{
P2HelperMidiState.OnSuccessfulRhythm(__instance);
}
}
}
[HarmonyPatch(typeof(Rhythm), "update")]
internal static class P2HelperWatchRhythmState
{
private static void Postfix(Rhythm __instance)
{
if (Plugin.HelperMuteEnabled && __instance != null)
{
P2HelperMidiState.CheckForRhythmLoss(__instance);
}
}
}
[HarmonyPatch(typeof(Rhythm), "clearPlayCount")]
internal static class P2HelperResetOnClearPlayCount
{
private static void Postfix()
{
if (Plugin.HelperMuteEnabled && (P2HelperMidiState.CommandsStarted || P2HelperMidiState.HelperMuted))
{
P2HelperMidiState.ResetProgress("Rhythm.clearPlayCount");
}
}
}
[HarmonyPatch(typeof(Rhythm), "resetPlayCount")]
internal static class P2HelperResetOnResetPlayCount
{
private static void Postfix()
{
if (Plugin.HelperMuteEnabled && (P2HelperMidiState.CommandsStarted || P2HelperMidiState.HelperMuted))
{
P2HelperMidiState.ResetProgress("Rhythm.resetPlayCount");
}
}
}
[HarmonyPatch]
internal static class P2CaptureHelperFromAddMidi_MidiId
{
private static MethodBase TargetMethod()
{
return AccessTools.DeclaredMethod(typeof(BgmPlayers), "addMidi", new Type[4]
{
typeof(BgmType),
typeof(MidiId),
typeof(MixingCategory),
typeof(SubGameType)
}, (Type[])null);
}
private static void Postfix(RhythmBgmPlayer __result, BgmType type, MidiId id, MixingCategory cate, SubGameType subGameType)
{
//IL_000e: 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_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
if (Plugin.HelperMuteEnabled)
{
P2HelperMidiState.CaptureHelperCandidate(__result, "BgmPlayers.addMidi(MidiId)", type, cate, subGameType, $"id={id}");
}
}
}
[HarmonyPatch]
internal static class P2CaptureHelperFromAddMidi_BankRid
{
private static MethodBase TargetMethod()
{
return AccessTools.DeclaredMethod(typeof(BgmPlayers), "addMidi", new Type[6]
{
typeof(BgmType),
typeof(BankRIDHandle),
typeof(RhythmParam),
typeof(string),
typeof(MixingCategory),
typeof(SubGameType)
}, (Type[])null);
}
private static void Postfix(RhythmBgmPlayer __result, BgmType type, BankRIDHandle rid, RhythmParam rhythmParam, string filename, MixingCategory cate, SubGameType subGameType)
{
//IL_000e: 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_0011: Unknown result type (might be due to invalid IL or missing references)
if (Plugin.HelperMuteEnabled)
{
P2HelperMidiState.CaptureHelperCandidate(__result, "BgmPlayers.addMidi(BankRIDHandle)", type, cate, subGameType, "filename=" + filename);
}
}
}
[HarmonyPatch(typeof(Director), "startBattle")]
internal static class P2HelperResetOnStartBattle
{
private static void Prefix(uint index)
{
if (Plugin.HelperMuteEnabled)
{
P2HelperMidiState.Reset($"Director.startBattle pre-reset index={index}");
P2HelperMidiState.BattleActive = true;
Plugin.D($"[P2 HELPER MIDI] battle active from Director.startBattle index={index}");
}
}
}
[HarmonyPatch(typeof(Director), "exitBattle")]
internal static class P2HelperResetOnExitBattle
{
private static void Prefix()
{
if (Plugin.HelperMuteEnabled)
{
P2HelperMidiState.Reset("Director.exitBattle");
}
}
}
[HarmonyPatch(typeof(Director), "failedBattle")]
internal static class P2HelperResetOnFailedBattle
{
private static void Prefix()
{
if (Plugin.HelperMuteEnabled)
{
P2HelperMidiState.Reset("Director.failedBattle");
}
}
}
[HarmonyPatch(typeof(Director), "goalBattle")]
internal static class P2HelperResetOnGoalBattle
{
private static void Prefix()
{
if (Plugin.HelperMuteEnabled)
{
P2HelperMidiState.Reset("Director.goalBattle");
}
}
}
[HarmonyPatch(typeof(Director), "onChangeMood")]
internal static class P2HelperResetOnChangeMood
{
private static void Postfix(Director __instance, int newMood, int oldMood)
{
//IL_0194: Unknown result type (might be due to invalid IL or missing references)
//IL_019b: Expected O, but got Unknown
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: 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)
//IL_0122: Unknown result type (might be due to invalid IL or missing references)
//IL_0125: Unknown result type (might be due to invalid IL or missing references)
//IL_0127: Invalid comparison between Unknown and I4
//IL_016e: Unknown result type (might be due to invalid IL or missing references)
//IL_0146: Unknown result type (might be due to invalid IL or missing references)
//IL_015a: Unknown result type (might be due to invalid IL or missing references)
//IL_0171: Unknown result type (might be due to invalid IL or missing references)
//IL_0173: Invalid comparison between Unknown and I4
if (!Plugin.HelperMuteEnabled)
{
return;
}
try
{
if (P2HelperMidiState.CommandsStarted || P2HelperMidiState.HelperMuted)
{
Mood val = (Mood)oldMood;
Mood val2 = (Mood)newMood;
int num = -999;
float num2 = -1f;
try
{
num = __instance.getCommandPoint();
num2 = __instance.getCommandBeatCount();
}
catch
{
}
Plugin.D($"[P2 HELPER MIDI] onChangeMood fired oldMood={val}, newMood={val2}, commandPoint={num}, commandBeatCount={num2}, commandsStarted={P2HelperMidiState.CommandsStarted}, helperMuted={P2HelperMidiState.HelperMuted}, helperPlayer={((P2HelperMidiState.HelperPlayer == null) ? "null" : "cached")}");
if ((int)val != 0 && (int)val2 == 0)
{
P2HelperMidiState.ResetProgress($"Director.onChangeMood {val}->{val2}");
}
else if ((int)val == 0 && (int)val2 == 0)
{
P2HelperMidiState.CheckLowLowMoodLoss("Director.onChangeMood Mood_Low->Mood_Low", num, num2);
}
}
}
catch (Exception ex)
{
ManualLogSource l = Plugin.L;
bool flag = default(bool);
BepInExWarningLogInterpolatedStringHandler val3 = new BepInExWarningLogInterpolatedStringHandler(43, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("[P2 HELPER MIDI] onChangeMood hook failed: ");
((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<Exception>(ex);
}
l.LogWarning(val3);
}
}
}
[HarmonyPatch(typeof(Rhythm), "playRhythm")]
internal static class P2HelperResetOnFailedPlayRhythm
{
private static void Postfix(Rhythm __instance, bool __result)
{
//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
//IL_00d9: Expected O, but got Unknown
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
if (!Plugin.HelperMuteEnabled)
{
return;
}
try
{
if (__instance != null && !__result && (P2HelperMidiState.CommandsStarted || P2HelperMidiState.HelperMuted))
{
Plugin.D($"[P2 HELPER MIDI] failed playRhythm detected: mood={__instance.lastMood_}, playCount={__instance.playCount_}, playSEIndex={__instance.playSEIndex_}, helperMuted={P2HelperMidiState.HelperMuted}");
P2HelperMidiState.ResetProgress("failed playRhythm");
}
}
catch (Exception ex)
{
ManualLogSource l = Plugin.L;
bool flag = default(bool);
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(48, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[P2 HELPER MIDI] failed playRhythm hook failed: ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
}
l.LogWarning(val);
}
}
}
}
