using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Threading;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("od.e")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Replaces How to Fish NPC dialogue and eating sounds with matching Minecraft audio.")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("MinecraftSoundReplacement")]
[assembly: AssemblyTitle("MinecraftSoundReplacement")]
[assembly: AssemblyVersion("1.0.0.0")]
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 HowToFish.MinecraftSoundReplacement
{
internal static class AudioAssets
{
private readonly struct WaveFormat
{
public ushort Encoding { get; }
public ushort Channels { get; }
public uint SampleRate { get; }
public ushort BlockAlign { get; }
public ushort BitsPerSample { get; }
public WaveFormat(ushort encoding, ushort channels, uint sampleRate, ushort blockAlign, ushort bitsPerSample)
{
Encoding = encoding;
Channels = channels;
SampleRate = sampleRate;
BlockAlign = blockAlign;
BitsPerSample = bitsPerSample;
}
}
private readonly struct WaveData
{
public int SampleRate { get; }
public int Channels { get; }
public float[] Samples { get; }
public WaveData(int sampleRate, int channels, float[] samples)
{
SampleRate = sampleRate;
Channels = channels;
Samples = samples;
}
}
private const BindingFlags PublicInstance = BindingFlags.Instance | BindingFlags.Public;
private const BindingFlags PublicStatic = BindingFlags.Static | BindingFlags.Public;
private static int _nextNpcTalking = -1;
private static int _nextEating = -1;
private static int _nextDrinking = -1;
private static int _nextBurp = -1;
public static IReadOnlyList<LoadedAudioClip> NpcTalking { get; private set; } = Array.Empty<LoadedAudioClip>();
public static IReadOnlyList<LoadedAudioClip> Eating { get; private set; } = Array.Empty<LoadedAudioClip>();
public static IReadOnlyList<LoadedAudioClip> Drinking { get; private set; } = Array.Empty<LoadedAudioClip>();
public static IReadOnlyList<LoadedAudioClip> Burps { get; private set; } = Array.Empty<LoadedAudioClip>();
public static void Load(string pluginDirectory, float gain, ManualLogSource log)
{
Type obj = AccessTools.TypeByName("UnityEngine.AudioClip") ?? throw new TypeLoadException("UnityEngine.AudioClip was not found.");
MethodInfo create = obj.GetMethods(BindingFlags.Static | BindingFlags.Public).Single((MethodInfo method) => method.Name == "Create" && method.GetParameters().Length == 5 && method.GetParameters()[0].ParameterType == typeof(string));
MethodInfo setData = obj.GetMethods(BindingFlags.Instance | BindingFlags.Public).Single((MethodInfo method) => method.Name == "SetData" && method.GetParameters().Length == 2 && method.GetParameters()[0].ParameterType == typeof(float[]));
string path = Path.Combine(pluginDirectory, "audio");
NpcTalking = LoadCategory(Path.Combine(path, "talking"), "NPC dialogue", gain, create, setData, log);
Eating = LoadCategory(Path.Combine(path, "eating"), "eating", gain, create, setData, log);
Drinking = LoadCategory(Path.Combine(path, "drinking"), "drinking", gain, create, setData, log);
Burps = LoadCategory(Path.Combine(path, "burp"), "burp", gain, create, setData, log);
}
public static LoadedAudioClip? NextNpcTalking()
{
return Next(NpcTalking, ref _nextNpcTalking);
}
public static LoadedAudioClip? NextEating()
{
return Next(Eating, ref _nextEating);
}
public static LoadedAudioClip? NextDrinking()
{
return Next(Drinking, ref _nextDrinking);
}
public static LoadedAudioClip? NextBurp()
{
return Next(Burps, ref _nextBurp);
}
private static IReadOnlyList<LoadedAudioClip> LoadCategory(string directory, string displayName, float gain, MethodInfo create, MethodInfo setData, ManualLogSource log)
{
if (!Directory.Exists(directory))
{
log.LogWarning((object)("No " + displayName + " audio directory found at '" + directory + "'; original sounds remain active."));
return Array.Empty<LoadedAudioClip>();
}
List<LoadedAudioClip> list = new List<LoadedAudioClip>();
bool flag = default(bool);
foreach (string item in Directory.GetFiles(directory, "*.wav", SearchOption.TopDirectoryOnly).OrderBy<string, string>((string path) => path, StringComparer.OrdinalIgnoreCase))
{
try
{
WaveData waveData = ReadWave(item);
NormalizeAndBoost(waveData.Samples, gain);
int num = list.Count + 1;
string text = $"MinecraftSoundReplacement_{displayName}_{num}";
object obj = create.Invoke(null, new object[5]
{
text,
waveData.Samples.Length / waveData.Channels,
waveData.Channels,
waveData.SampleRate,
false
}) ?? throw new InvalidOperationException("Unity returned a null AudioClip.");
object obj2 = setData.Invoke(obj, new object[2] { waveData.Samples, 0 });
int num2;
if (obj2 is bool)
{
flag = (bool)obj2;
num2 = 1;
}
else
{
num2 = 0;
}
if (((uint)num2 & (flag ? 1u : 0u)) == 0)
{
throw new InvalidOperationException("Unity AudioClip.SetData rejected the decoded samples.");
}
list.Add(new LoadedAudioClip(obj, num));
}
catch (Exception exception)
{
log.LogError((object)("Could not load " + displayName + " clip '" + item + "': " + Unwrap(exception).Message));
}
}
if (list.Count == 0)
{
log.LogWarning((object)("No valid PCM WAV files were found for " + displayName + "; original sounds remain active."));
}
return list;
}
private static LoadedAudioClip? Next(IReadOnlyList<LoadedAudioClip> values, ref int counter)
{
if (values.Count == 0)
{
return null;
}
int num = Interlocked.Increment(ref counter) & 0x7FFFFFFF;
return values[num % values.Count];
}
private static WaveData ReadWave(string path)
{
using FileStream fileStream = File.OpenRead(path);
using BinaryReader binaryReader = new BinaryReader(fileStream);
if (ReadFourCc(binaryReader) != "RIFF")
{
throw new InvalidDataException("Expected a RIFF header.");
}
binaryReader.ReadUInt32();
if (ReadFourCc(binaryReader) != "WAVE")
{
throw new InvalidDataException("Expected WAVE data.");
}
WaveFormat? waveFormat = null;
byte[] array = null;
while (fileStream.Position + 8 <= fileStream.Length)
{
string text = ReadFourCc(binaryReader);
uint num = binaryReader.ReadUInt32();
long num2 = checked(fileStream.Position + num);
if (num2 > fileStream.Length)
{
throw new InvalidDataException("Chunk '" + text + "' extends past the end of the file.");
}
if (text == "fmt ")
{
if (num < 16)
{
throw new InvalidDataException("The WAV format chunk is too short.");
}
ushort encoding = binaryReader.ReadUInt16();
ushort channels = binaryReader.ReadUInt16();
uint sampleRate = binaryReader.ReadUInt32();
binaryReader.ReadUInt32();
ushort blockAlign = binaryReader.ReadUInt16();
ushort bitsPerSample = binaryReader.ReadUInt16();
waveFormat = new WaveFormat(encoding, channels, sampleRate, blockAlign, bitsPerSample);
}
else if (text == "data")
{
if (num > int.MaxValue)
{
throw new InvalidDataException("The WAV data chunk is too large.");
}
array = binaryReader.ReadBytes((int)num);
if (array.Length != (int)num)
{
throw new EndOfStreamException("The WAV data chunk ended unexpectedly.");
}
}
fileStream.Position = num2 + (num & 1);
}
if (!waveFormat.HasValue || array == null)
{
throw new InvalidDataException("The WAV file must contain both 'fmt ' and 'data' chunks.");
}
return Decode(waveFormat.Value, array);
}
private static WaveData Decode(WaveFormat format, byte[] bytes)
{
if (format.Channels == 0 || format.Channels > 8 || format.SampleRate == 0 || format.SampleRate > 384000)
{
throw new InvalidDataException("The channel count or sample rate is invalid.");
}
int num = (format.BitsPerSample + 7) / 8;
int num2 = checked(format.Channels * num);
if (num == 0 || format.BlockAlign != num2 || bytes.Length % format.BlockAlign != 0)
{
throw new InvalidDataException("The WAV block alignment is invalid.");
}
float[] array = new float[bytes.Length / num];
if (format.Encoding == 1)
{
DecodePcm(format.BitsPerSample, bytes, array);
}
else
{
if (format.Encoding != 3 || format.BitsPerSample != 32)
{
throw new InvalidDataException($"Unsupported WAV encoding {format.Encoding} at {format.BitsPerSample} bits. " + "Use uncompressed PCM (8/16/24/32-bit) or 32-bit IEEE float WAV.");
}
for (int i = 0; i < array.Length; i++)
{
float num3 = BitConverter.ToSingle(bytes, i * 4);
array[i] = (float.IsNaN(num3) ? 0f : Math.Max(-1f, Math.Min(1f, num3)));
}
}
return new WaveData((int)format.SampleRate, format.Channels, array);
}
private static void NormalizeAndBoost(float[] samples, float userGain)
{
if (samples.Length == 0)
{
return;
}
double num = 0.0;
foreach (float num2 in samples)
{
num += (double)(num2 * num2);
}
double num3 = Math.Sqrt(num / (double)samples.Length);
if (!(num3 < 1E-06))
{
double num4 = Math.Min(12.0, 0.18 / num3) * Math.Max(0.25, Math.Min(4.0, userGain));
for (int j = 0; j < samples.Length; j++)
{
samples[j] = (float)(0.98 * Math.Tanh((double)samples[j] * num4 / 0.98));
}
}
}
private static void DecodePcm(ushort bitsPerSample, byte[] bytes, float[] samples)
{
switch (bitsPerSample)
{
case 8:
{
for (int l = 0; l < samples.Length; l++)
{
samples[l] = (float)(bytes[l] - 128) / 128f;
}
break;
}
case 16:
{
for (int j = 0; j < samples.Length; j++)
{
samples[j] = (float)BitConverter.ToInt16(bytes, j * 2) / 32768f;
}
break;
}
case 24:
{
for (int k = 0; k < samples.Length; k++)
{
int num = k * 3;
int num2 = bytes[num] | (bytes[num + 1] << 8) | (bytes[num + 2] << 16);
if ((num2 & 0x800000) != 0)
{
num2 |= -16777216;
}
samples[k] = (float)num2 / 8388608f;
}
break;
}
case 32:
{
for (int i = 0; i < samples.Length; i++)
{
samples[i] = (float)BitConverter.ToInt32(bytes, i * 4) / 2.1474836E+09f;
}
break;
}
default:
throw new InvalidDataException($"Unsupported PCM bit depth {bitsPerSample}. Use 8, 16, 24, or 32-bit PCM WAV.");
}
}
private static string ReadFourCc(BinaryReader reader)
{
return new string(reader.ReadChars(4));
}
private static Exception Unwrap(Exception exception)
{
while (exception is TargetInvocationException && exception.InnerException != null)
{
exception = exception.InnerException;
}
return exception;
}
}
internal sealed class LoadedAudioClip
{
public object UnityClip { get; }
public int CategoryIndex { get; }
public LoadedAudioClip(object unityClip, int categoryIndex)
{
UnityClip = unityClip;
CategoryIndex = categoryIndex;
}
}
[BepInPlugin("od.e.howtofish.minecraftsoundreplacement", "Minecraft Sound Replacement", "1.0.0")]
public sealed class MinecraftSoundReplacementPlugin : BaseUnityPlugin
{
public const string PluginGuid = "od.e.howtofish.minecraftsoundreplacement";
public const string PluginName = "Minecraft Sound Replacement";
public const string PluginVersion = "1.0.0";
private const string FurModelReplaceGuid = "dev.codex.howtofish.furmodelreplace";
private static readonly Guid SupportedGameMvid = new Guid("5bfce772-ee82-40f5-9e5b-e1cd1212f3dd");
private const string SupportedUnityVersion = "6000.4.4f1";
private const BindingFlags AllMembers = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
[ThreadStatic]
private static int _npcEatingDepth;
private static ManualLogSource _log = null;
private static FieldInfo _npcMouthSource = null;
private static FieldInfo _npcMouthVolume = null;
private static FieldInfo _playerEatSource = null;
private static FieldInfo _playerEatClip = null;
private static FieldInfo _playerDrinkClip = null;
private static FieldInfo _playerEatVolume = null;
private static FieldInfo _playerDrinkVolume = null;
private static FieldInfo _playerIsEating = null;
private static FieldInfo _audioManagerClips = null;
private static PropertyInfo _audioSourceClip = null;
private static PropertyInfo _audioSourceIsPlaying = null;
private Harmony? _harmony;
private void Awake()
{
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Expected O, but got Unknown
//IL_0218: Unknown result type (might be due to invalid IL or missing references)
//IL_0222: Expected O, but got Unknown
_log = ((BaseUnityPlugin)this).Logger;
try
{
ConfigEntry<float> val = ((BaseUnityPlugin)this).Config.Bind<float>("Audio", "Gain", 1.5f, new ConfigDescription("Extra gain applied after loudness normalization. Restart the game after changing it.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 4f), Array.Empty<object>()));
AudioAssets.Load(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) ?? Paths.PluginPath, val.Value, ((BaseUnityPlugin)this).Logger);
Type type = RequireType("NPC");
Type type2 = RequireType("PlayerEating");
Type type3 = RequireType("AudioManager");
Type type4 = RequireType("UnityEngine.AudioSource");
_npcMouthSource = RequireField(type, "_mouthSource");
_npcMouthVolume = RequireField(type, "_mouthVol");
_playerEatSource = RequireField(type2, "_eatSoundSource");
_playerEatClip = RequireField(type2, "_eatSound");
_playerDrinkClip = RequireField(type2, "_drinkSound");
_playerEatVolume = RequireField(type2, "_eatSoundVolume");
_playerDrinkVolume = RequireField(type2, "_drinkSoundVolume");
_playerIsEating = RequireField(type2, "_localIsEating");
_audioManagerClips = RequireField(type3, "_realClips");
_audioSourceClip = RequireProperty(type4, "clip");
_audioSourceIsPlaying = RequireProperty(type4, "isPlaying");
MethodInfo methodInfo = RequireMethod(type, "SetNpcText", 4);
Guid moduleVersionId = methodInfo.DeclaringType.Assembly.ManifestModule.ModuleVersionId;
if (moduleVersionId != SupportedGameMvid)
{
((BaseUnityPlugin)this).Logger.LogWarning((object)("This game assembly differs from Steam build 24911270 " + $"(expected MVID {SupportedGameMvid}, found {moduleVersionId})."));
}
string text = RequireType("UnityEngine.Application").GetProperty("unityVersion", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(null, null)?.ToString();
if (!string.Equals(text, "6000.4.4f1", StringComparison.Ordinal))
{
((BaseUnityPlugin)this).Logger.LogWarning((object)("This mod targets Unity 6000.4.4f1; the running game reports " + (text ?? "<unknown>") + "."));
}
_harmony = new Harmony("od.e.howtofish.minecraftsoundreplacement");
Patch(methodInfo, "ConfigureNpcTalking", null);
MethodInfo original = AccessTools.EnumeratorMoveNext((MethodBase)RequireMethod(type, "EatEffects", 0)) ?? throw new MissingMethodException("NPC", "EatEffects iterator MoveNext");
Patch(original, "BeforeNpcEating", "AfterNpcEating");
Patch(RequireMethod(type2, "OnStartClient", 0), null, "ConfigurePlayerEating");
Patch(RequireMethod(type2, "UpdateEating", 0), "PreparePlayerEatingSound", null);
Patch(RequireMethod(type3, "Start", 0), null, "RegisterAudioClips");
Patch(RequireMethod(type3, "PlayClipAt", 6), "ReplaceNpcEatingSound", null);
Patch(RequireMethod(type3, "PlayPlayerClip", 6), "ReplacePlayerSwallow", null);
((BaseUnityPlugin)this).Logger.LogInfo((object)($"Minecraft Sound Replacement is active with {AudioAssets.NpcTalking.Count} NPC dialogue, " + $"{AudioAssets.Eating.Count} eating, {AudioAssets.Drinking.Count} drinking, and " + $"{AudioAssets.Burps.Count} burp clip(s); normalized gain={val.Value:0.##}x."));
}
catch (Exception exception)
{
((BaseUnityPlugin)this).Logger.LogError((object)"Minecraft Sound Replacement could not install its patches.");
((BaseUnityPlugin)this).Logger.LogError((object)Unwrap(exception));
Harmony? harmony = _harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
_harmony = null;
}
}
private void OnDestroy()
{
Harmony? harmony = _harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
private void Patch(MethodInfo original, string? prefixName, string? postfixName)
{
_harmony.Patch((MethodBase)original, (prefixName == null) ? null : CreatePatch(prefixName), (postfixName == null) ? null : CreatePatch(postfixName), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
}
private static HarmonyMethod CreatePatch(string name)
{
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Expected O, but got Unknown
return new HarmonyMethod(typeof(MinecraftSoundReplacementPlugin).GetMethod(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic) ?? throw new MissingMethodException(typeof(MinecraftSoundReplacementPlugin).FullName, name), 0, (string[])null, new string[1] { "dev.codex.howtofish.furmodelreplace" }, (bool?)null);
}
private static void ConfigureNpcTalking(object __instance)
{
LoadedAudioClip loadedAudioClip = AudioAssets.NextNpcTalking();
object value = _npcMouthSource.GetValue(__instance);
if (loadedAudioClip != null && value != null)
{
_audioSourceClip.SetValue(value, loadedAudioClip.UnityClip, null);
_npcMouthVolume.SetValue(__instance, 1f);
}
}
private static void BeforeNpcEating()
{
_npcEatingDepth++;
}
private static void AfterNpcEating()
{
if (_npcEatingDepth > 0)
{
_npcEatingDepth--;
}
}
private static void ConfigurePlayerEating(object __instance)
{
LoadedAudioClip loadedAudioClip = AudioAssets.NextEating();
LoadedAudioClip loadedAudioClip2 = AudioAssets.NextDrinking();
if (loadedAudioClip != null)
{
_playerEatClip.SetValue(__instance, loadedAudioClip.UnityClip);
_playerEatVolume.SetValue(__instance, 1f);
}
if (loadedAudioClip2 != null)
{
_playerDrinkClip.SetValue(__instance, loadedAudioClip2.UnityClip);
_playerDrinkVolume.SetValue(__instance, 1f);
}
}
private static void PreparePlayerEatingSound(object __instance)
{
if (AudioAssets.Eating.Count == 0)
{
return;
}
object value = _playerIsEating.GetValue(__instance);
if (!(value is bool) || !(bool)value)
{
return;
}
object value2 = _playerEatSource.GetValue(__instance);
if (value2 == null)
{
return;
}
value = _audioSourceIsPlaying.GetValue(value2, null);
bool flag = default(bool);
int num;
if (value is bool)
{
flag = (bool)value;
num = 1;
}
else
{
num = 0;
}
if (((uint)num & (flag ? 1u : 0u)) == 0)
{
LoadedAudioClip loadedAudioClip = AudioAssets.NextEating();
if (loadedAudioClip != null)
{
_playerEatClip.SetValue(__instance, loadedAudioClip.UnityClip);
_playerEatVolume.SetValue(__instance, 1f);
_playerDrinkVolume.SetValue(__instance, 1f);
}
}
}
private static void RegisterAudioClips()
{
if (!(_audioManagerClips.GetValue(null) is IDictionary dictionary))
{
_log.LogError((object)"Could not access AudioManager._realClips; NPC eating and final burp remain unchanged.");
return;
}
Register(dictionary, "MinecraftEat", AudioAssets.Eating);
Register(dictionary, "MinecraftDrink", AudioAssets.Drinking);
Register(dictionary, "MinecraftBurp", AudioAssets.Burps);
}
private static void ReplaceNpcEatingSound(ref string clip, ref float volume)
{
if (_npcEatingDepth > 0 && AudioAssets.Eating.Count != 0)
{
LoadedAudioClip loadedAudioClip = AudioAssets.NextEating();
if (loadedAudioClip != null)
{
clip = $"MinecraftEat{loadedAudioClip.CategoryIndex}";
volume = Math.Max(volume, 1f);
}
}
}
private static void ReplacePlayerSwallow(ref string clip, ref float volume)
{
if (AudioAssets.Burps.Count != 0 && (string.Equals(clip, "Swallow", StringComparison.Ordinal) || clip.StartsWith("FurPlayerEating", StringComparison.Ordinal)))
{
LoadedAudioClip loadedAudioClip = AudioAssets.NextBurp();
if (loadedAudioClip != null)
{
clip = $"MinecraftBurp{loadedAudioClip.CategoryIndex}";
volume = Math.Max(volume, 1f);
}
}
}
private static void Register(IDictionary dictionary, string prefix, IReadOnlyList<LoadedAudioClip> clips)
{
foreach (LoadedAudioClip clip in clips)
{
dictionary[$"{prefix}{clip.CategoryIndex}"] = clip.UnityClip;
}
}
private static Type RequireType(string typeName)
{
return AccessTools.TypeByName(typeName) ?? throw new TypeLoadException("Required runtime type '" + typeName + "' was not found.");
}
private static MethodInfo RequireMethod(Type type, string methodName, int parameterCount)
{
MethodInfo[] array = (from method in type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
where method.Name == methodName && method.GetParameters().Length == parameterCount
select method).ToArray();
if (array.Length != 1)
{
throw new MissingMethodException(type.FullName, $"{methodName} with {parameterCount} parameter(s); found {array.Length}");
}
return array[0];
}
private static FieldInfo RequireField(Type type, string fieldName)
{
return type.GetField(fieldName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic) ?? throw new MissingFieldException(type.FullName, fieldName);
}
private static PropertyInfo RequireProperty(Type type, string propertyName)
{
return type.GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic) ?? throw new MissingMemberException(type.FullName, propertyName);
}
private static Exception Unwrap(Exception exception)
{
while (exception is TargetInvocationException && exception.InnerException != null)
{
exception = exception.InnerException;
}
return exception;
}
}
}
