using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;
using UnityEngine.SceneManagement;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("LogNeuter")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("LogNeuter")]
[assembly: AssemblyCopyright("Copyright © BlueAmulet 2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("de27b4d1-820d-4505-a953-6001420281e4")]
[assembly: AssemblyFileVersion("1.0.3")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyVersion("1.0.3.0")]
namespace LogNeuter;
[BepInPlugin("BlueAmulet.LogNeuter", "LogNeuter", "1.0.3")]
public class LogNeuter : BaseUnityPlugin
{
internal const string Name = "LogNeuter";
internal const string Author = "BlueAmulet";
internal const string Version = "1.0.3";
private const string ID = "BlueAmulet.LogNeuter";
private static ManualLogSource Log;
private static ConfigFile ConfigFile;
private const int ConfVersion = 1;
private static ConfigEntry<int> version;
private static ConfigEntry<bool> fixSpatializer;
private static ConfigEntry<bool> fixLookRotation;
private static ConfigEntry<bool> genBlockAll;
private static bool allowSave = false;
private static bool warnSave = true;
private static readonly Harmony harmony = new Harmony("BlueAmulet.LogNeuter");
private static readonly HarmonyMethod transpiler = new HarmonyMethod(AccessTools.Method(typeof(LogNeuter), "Transpiler", (Type[])null, (Type[])null));
private static readonly Dictionary<string, HashSet<string>> staticLogs = new Dictionary<string, HashSet<string>>();
private static readonly Dictionary<string, List<Regex>> dynamicLogs = new Dictionary<string, List<Regex>>();
private static StreamWriter genFile;
public void Awake()
{
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Expected O, but got Unknown
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Expected O, but got Unknown
//IL_0372: Unknown result type (might be due to invalid IL or missing references)
//IL_0379: Expected O, but got Unknown
//IL_0251: Unknown result type (might be due to invalid IL or missing references)
//IL_0258: Expected O, but got Unknown
//IL_026e: Unknown result type (might be due to invalid IL or missing references)
//IL_0275: Expected O, but got Unknown
Log = ((BaseUnityPlugin)this).Logger;
ConfigFile = ((BaseUnityPlugin)this).Config;
SceneManager.sceneLoaded += OnSceneLoaded;
MethodBase methodBase = AccessTools.Method(typeof(ConfigFile), "Save", (Type[])null, (Type[])null);
HarmonyMethod val = new HarmonyMethod(AccessTools.Method(typeof(LogNeuter), "PrefixConfigSave", (Type[])null, (Type[])null));
harmony.Patch(methodBase, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
if (AccessTools.DeclaredPropertyGetter(typeof(ConfigFile), "OrphanedEntries")?.Invoke(((BaseUnityPlugin)this).Config, null) is Dictionary<ConfigDefinition, string> dictionary)
{
ConfigDefinition key = new ConfigDefinition("Config", "Version");
if (dictionary.Count != 0 && !dictionary.ContainsKey(key))
{
dictionary[key] = "0";
}
}
warnSave = false;
version = ((BaseUnityPlugin)this).Config.Bind<int>("Config", "Version", 1, "Disable broken spatialize on audio sources");
fixSpatializer = ((BaseUnityPlugin)this).Config.Bind<bool>("Config", "FixSpatializer", true, "Disable broken spatialize on audio sources");
fixLookRotation = ((BaseUnityPlugin)this).Config.Bind<bool>("Config", "FixLookRotation", true, "Mask \"Look rotation viewing vector is zero\" messages");
genBlockAll = ((BaseUnityPlugin)this).Config.Bind<bool>("Config", "GenBlockAll", false, "Generate a config file that blocks all logging");
warnSave = true;
if (version.Value < 1)
{
((BaseUnityPlugin)this).Logger.LogWarning((object)$"Configuration out of date, expected version {1}, got {version.Value}");
}
else if (version.Value > 1)
{
((BaseUnityPlugin)this).Logger.LogError((object)$"Configuration too new, expected version {1}, got {version.Value}");
}
if (genBlockAll.Value)
{
Assembly assembly = Array.Find(AppDomain.CurrentDomain.GetAssemblies(), (Assembly a) => a.GetName().Name == "Assembly-CSharp");
if (assembly != null)
{
genFile = new StreamWriter(Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Config.ConfigFilePath), "BlueAmulet.LogNeuter.Generated.cfg"), append: false, Encoding.UTF8);
genFile.WriteLine("## This is a generated file, it does not actively do anything and only serves as reference for the real config file");
Harmony val2 = new Harmony("BlueAmulet.LogNeuter.Generated");
HarmonyMethod val3 = new HarmonyMethod(AccessTools.Method(typeof(LogNeuter), "TranspilerGen", (Type[])null, (Type[])null));
Type[] types = assembly.GetTypes();
foreach (Type type in types)
{
((BaseUnityPlugin)this).Logger.LogInfo((object)("Scanning " + type.FullName));
MethodInfo[] methods = type.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
foreach (MethodInfo methodInfo in methods)
{
try
{
val2.Patch((MethodBase)methodInfo, (HarmonyMethod)null, (HarmonyMethod)null, val3, (HarmonyMethod)null, (HarmonyMethod)null);
val2.Unpatch((MethodBase)methodInfo, (HarmonyPatchType)3, "BlueAmulet.LogNeuter.Generated");
}
catch (HarmonyException)
{
}
}
}
genFile.Close();
}
else
{
((BaseUnityPlugin)this).Logger.LogError((object)"Could not find Assembly-CSharp, generation skipped");
}
}
if (fixLookRotation.Value)
{
MethodBase methodBase2 = AccessTools.Method(typeof(Quaternion), "LookRotation", new Type[2]
{
typeof(Vector3),
typeof(Vector3)
}, (Type[])null);
HarmonyMethod val5 = new HarmonyMethod(AccessTools.Method(typeof(LogNeuter), "TranspilerLookRotation", (Type[])null, (Type[])null));
harmony.Patch(methodBase2, (HarmonyMethod)null, (HarmonyMethod)null, val5, (HarmonyMethod)null, (HarmonyMethod)null);
}
if (File.Exists(((BaseUnityPlugin)this).Config.ConfigFilePath))
{
MethodBase methodBase3 = null;
string text = null;
foreach (string item in File.ReadLines(((BaseUnityPlugin)this).Config.ConfigFilePath))
{
string text2 = item.Trim();
if (text2.Length == 0 || text2.StartsWith("#"))
{
continue;
}
if (text2.StartsWith("[") && text2.EndsWith("]"))
{
PatchMethod(methodBase3);
methodBase3 = null;
staticLogs.Clear();
text = text2.Substring(1, text2.Length - 2);
if (!text.Contains("|"))
{
continue;
}
string[] array = text.Split(new char[1] { '|' }, 2);
if (array.Length == 2)
{
string text3 = array[0];
if (!text3.Contains(","))
{
text3 += ", Assembly-CSharp";
}
Type type2 = Type.GetType(text3);
if (type2 == null)
{
((BaseUnityPlugin)this).Logger.LogWarning((object)("Could not find type: " + array[0]));
continue;
}
try
{
methodBase3 = AccessTools.Method(type2, array[1], (Type[])null, (Type[])null);
if (methodBase3 == null)
{
((BaseUnityPlugin)this).Logger.LogWarning((object)("Could not find method: " + text));
}
}
catch (AmbiguousMatchException ex)
{
methodBase3 = null;
((BaseUnityPlugin)this).Logger.LogError((object)ex);
}
}
else
{
((BaseUnityPlugin)this).Logger.LogWarning((object)("Unknown entry: " + text));
}
}
else
{
if (text == null)
{
continue;
}
if (text2.StartsWith("^") && text2.EndsWith("$"))
{
if (!dynamicLogs.ContainsKey(text))
{
dynamicLogs[text] = new List<Regex>();
}
dynamicLogs[text].Add(new Regex(text2, RegexOptions.Compiled));
}
else
{
if (!staticLogs.ContainsKey(text))
{
staticLogs[text] = new HashSet<string>();
}
staticLogs[text].Add(text2);
}
}
}
PatchMethod(methodBase3);
}
else
{
allowSave = true;
((BaseUnityPlugin)this).Config.Save();
allowSave = false;
}
int num = 0;
foreach (MethodBase patchedMethod in harmony.GetPatchedMethods())
{
((BaseUnityPlugin)this).Logger.LogInfo((object)("Patched " + patchedMethod.DeclaringType.Name + "." + patchedMethod.Name));
num++;
}
((BaseUnityPlugin)this).Logger.LogInfo((object)(num + " patches applied"));
}
private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
{
if (!fixSpatializer.Value)
{
return;
}
int num = 0;
AudioSource[] array = Resources.FindObjectsOfTypeAll<AudioSource>();
foreach (AudioSource val in array)
{
if (val.spatialize)
{
val.spatialize = false;
num++;
}
}
if (num > 0)
{
((BaseUnityPlugin)this).Logger.LogInfo((object)$"Fixed {num} spatilization settings");
}
}
private static bool PrefixConfigSave(ref ConfigFile __instance)
{
if (__instance == ConfigFile && !allowSave)
{
if (warnSave)
{
Log.LogWarning((object)"Saving LogNeuter config blocked for data loss prevention");
}
return false;
}
return true;
}
private static IEnumerable<CodeInstruction> TranspilerLookRotation(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Expected O, but got Unknown
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Expected O, but got Unknown
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Expected O, but got Unknown
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: Expected O, but got Unknown
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
//IL_00bb: Expected O, but got Unknown
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
//IL_00cc: Expected O, but got Unknown
List<CodeInstruction> list = new List<CodeInstruction>(instructions);
Label label = generator.DefineLabel();
list[0].labels.Add(label);
list.InsertRange(0, new List<CodeInstruction>
{
new CodeInstruction(OpCodes.Ldarg_0, (object)null),
new CodeInstruction(OpCodes.Call, (object)AccessTools.PropertyGetter(typeof(Vector3), "zero")),
new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Vector3), "op_Equality", (Type[])null, (Type[])null)),
new CodeInstruction(OpCodes.Brfalse_S, (object)label),
new CodeInstruction(OpCodes.Call, (object)AccessTools.PropertyGetter(typeof(Quaternion), "identity")),
new CodeInstruction(OpCodes.Ret, (object)null)
});
return list;
}
private static void PatchMethod(MethodBase patchMethod)
{
//IL_0043: Expected O, but got Unknown
if (!(patchMethod != null))
{
return;
}
string key = SectionName(patchMethod);
if (staticLogs.ContainsKey(key) || dynamicLogs.ContainsKey(key))
{
try
{
harmony.Patch(patchMethod, (HarmonyMethod)null, (HarmonyMethod)null, transpiler, (HarmonyMethod)null, (HarmonyMethod)null);
}
catch (HarmonyException val)
{
HarmonyException val2 = val;
Log.LogError((object)val2);
}
}
}
private static string SectionName(MethodBase method)
{
Type declaringType = method.DeclaringType;
string name = declaringType.Assembly.GetName().Name;
if (name == "Assembly-CSharp")
{
return declaringType.FullName + "|" + method.Name;
}
return declaringType.FullName + ", " + name + "|" + method.Name;
}
private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, MethodBase original)
{
//IL_0158: Unknown result type (might be due to invalid IL or missing references)
//IL_0162: Expected O, but got Unknown
//IL_016a: Unknown result type (might be due to invalid IL or missing references)
//IL_0174: Expected O, but got Unknown
//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
//IL_00ff: Expected O, but got Unknown
string text = SectionName(original);
bool flag = false;
List<CodeInstruction> list = new List<CodeInstruction>(instructions);
for (int i = 1; i < list.Count; i++)
{
CodeInstruction val = list[i];
if (!(val.opcode == OpCodes.Call) || !(val.operand is MethodInfo methodInfo) || !methodInfo.IsStatic || !(methodInfo.DeclaringType == typeof(Debug)) || !methodInfo.Name.StartsWith("Log") || !(methodInfo.Name != "LogException"))
{
continue;
}
CodeInstruction val2 = list[i - 1];
if (val2.opcode == OpCodes.Ldstr)
{
if (staticLogs.ContainsKey(text) && staticLogs[text].Contains((string)val2.operand))
{
list[i] = new CodeInstruction(OpCodes.Pop, (object)null);
flag = true;
}
}
else if (dynamicLogs.ContainsKey(text))
{
string text2 = methodInfo.Name + methodInfo.GetParameters().Length;
MethodInfo methodInfo2 = AccessTools.Method(typeof(LogNeuter), text2, (Type[])null, (Type[])null);
if (methodInfo2 != null)
{
list[i] = new CodeInstruction(OpCodes.Call, (object)methodInfo2);
list.Insert(i, new CodeInstruction(OpCodes.Ldstr, (object)text));
flag = true;
}
}
}
if (!flag)
{
Log.LogWarning((object)("Made no changes to method: " + text));
}
return list;
}
private static void GenWriteEntry(ref bool wroteHeader, string section, HashSet<string> strings, string log)
{
if (!strings.Contains(log))
{
strings.Add(log);
if (!wroteHeader)
{
genFile.WriteLine();
genFile.WriteLine("[" + section + "]");
wroteHeader = true;
}
if (!log.Contains("="))
{
genFile.WriteLine(log);
}
}
}
private static IEnumerable<CodeInstruction> TranspilerGen(IEnumerable<CodeInstruction> instructions, MethodBase original)
{
List<CodeInstruction> list = new List<CodeInstruction>(instructions);
Stream baseStream = genFile.BaseStream;
if (baseStream != null && baseStream.CanWrite)
{
string section = SectionName(original);
bool wroteHeader = false;
HashSet<string> strings = new HashSet<string>();
for (int i = 1; i < list.Count; i++)
{
CodeInstruction val = list[i];
if (!(val.opcode == OpCodes.Call) || !(val.operand is MethodInfo methodInfo) || !methodInfo.IsStatic || !(methodInfo.DeclaringType == typeof(Debug)) || !methodInfo.Name.StartsWith("Log"))
{
continue;
}
CodeInstruction val2 = list[i - 1];
if (val2.opcode == OpCodes.Ldstr)
{
GenWriteEntry(ref wroteHeader, section, strings, (string)val2.operand);
}
else
{
if (!(val2.opcode == OpCodes.Call) || !(val2.operand is MethodInfo methodInfo2) || !methodInfo2.IsStatic || !(methodInfo2.DeclaringType == typeof(string)) || !(methodInfo2.Name == "Format"))
{
continue;
}
ParameterInfo[] parameters = methodInfo2.GetParameters();
if (parameters.Length == 0 || !(parameters[0].ParameterType == typeof(string)))
{
continue;
}
int num = i;
do
{
num--;
}
while ((list[num].opcode != OpCodes.Ldstr || !((string)list[num].operand).Contains("{")) && num > 0);
CodeInstruction val3 = list[num];
if (val3.opcode == OpCodes.Ldstr)
{
string text = (string)val3.operand;
if (text.Contains("{") && text.Contains("}"))
{
string text2 = Regex.Escape(text);
text2 = text2.Replace("\\ ", " ");
text2 = Regex.Replace(text2, "\\\\{[0-9]+}", ".*?");
GenWriteEntry(ref wroteHeader, section, strings, "^" + text2 + "$");
}
}
}
}
}
return list;
}
private static bool MatchAny(string section, string log)
{
if (section == null || !dynamicLogs.ContainsKey(section))
{
return false;
}
foreach (Regex item in dynamicLogs[section])
{
if (item.IsMatch(log))
{
return true;
}
}
return false;
}
public static void Log1(object message, string section)
{
if (!MatchAny(section, message.ToString()))
{
Debug.Log(message);
}
}
public static void LogWarning1(object message, string section)
{
if (!MatchAny(section, message.ToString()))
{
Debug.LogWarning(message);
}
}
public static void LogWarning2(object message, Object context, string section)
{
if (!MatchAny(section, message.ToString()))
{
Debug.LogWarning(message, context);
}
}
public static void LogError1(object message, string section)
{
if (!MatchAny(section, message.ToString()))
{
Debug.LogError(message);
}
}
public static void LogError2(object message, Object context, string section)
{
if (!MatchAny(section, message.ToString()))
{
Debug.LogError(message, context);
}
}
}
