using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.TextMeshPro")]
[assembly: IgnoresAccessChecksTo("UnityEngine.UI")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("CFEELowVersionFix")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Low-version compatibility fix for CoordinateForEasterEggs.")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0+8dc079a6e01835fdf42f254d7f6af108b1baa7e5")]
[assembly: AssemblyProduct("CFEELowVersionFix")]
[assembly: AssemblyTitle("CFEELowVersionFix")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.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 Asta.CfeeLowVersionFix
{
[BepInPlugin("asta.cfee.lowverfix", "CFEE Low Version Fix", "0.1.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public sealed class CfeeLowVersionFixPlugin : BaseUnityPlugin
{
internal const string PluginGuid = "asta.cfee.lowverfix";
internal const string PluginName = "CFEE Low Version Fix";
internal const string PluginVersion = "0.1.0";
internal static ManualLogSource Log;
internal static Harmony HarmonyInstance;
private void Awake()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
Log = ((BaseUnityPlugin)this).Logger;
HarmonyInstance = new Harmony("asta.cfee.lowverfix");
HarmonyInstance.PatchAll();
OriginalCfeeHooks.Install(HarmonyInstance);
Log.LogInfo((object)"CFEE Low Version Fix loaded.");
}
private void Start()
{
OriginalCfeeHooks.Install(HarmonyInstance);
}
}
internal static class OriginalCfeeHooks
{
private const BindingFlags AnyMethod = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
private static readonly HashSet<string> InstalledTargets = new HashSet<string>(StringComparer.Ordinal);
private static MethodInfo? _generateEggLineMethod;
private static bool _loggedGenerateEggLineFailure;
internal static void Install(Harmony harmony)
{
TryInstallBypassPatch(harmony, "testModLethalCompany.Patches.CoordinateForEasterEggs", "CoordinateForEasterEggs", "SetExplodeOnThrowClinetRPCExtension", "SkipOriginalSetExplodeExtension");
TryInstallBypassPatch(harmony, "testModLethalCompany.EggLineSync", "EggLineSync", "EggLinesClientRpc", "SkipEggLinesClientRpc");
}
internal static bool TryGenerateEggLine(Vector3 position, bool explodeOnThrow)
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
MethodInfo methodInfo = ResolveGenerateEggLineMethod();
if ((object)methodInfo == null)
{
return false;
}
try
{
methodInfo.Invoke(null, new object[2] { position, explodeOnThrow });
return true;
}
catch (Exception arg)
{
CfeeLowVersionFixPlugin.Log.LogError((object)$"Failed to invoke CoordinateForEasterEggs.GenerateEggLine: {arg}");
return false;
}
}
private static bool SkipOriginalSetExplodeExtension()
{
return false;
}
private static bool SkipEggLinesClientRpc()
{
return false;
}
private static void TryInstallBypassPatch(Harmony harmony, string fullTypeName, string fallbackTypeName, string methodName, string prefixName)
{
//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
//IL_00db: Expected O, but got Unknown
string methodName2 = methodName;
Type type = FindType(fullTypeName, fallbackTypeName);
if ((object)type == null)
{
return;
}
MethodInfo methodInfo = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo method) => string.Equals(method.Name, methodName2, StringComparison.Ordinal));
if ((object)methodInfo == null)
{
return;
}
string text = methodInfo.DeclaringType?.FullName + "." + methodInfo.Name;
if (InstalledTargets.Add(text))
{
MethodInfo method2 = typeof(OriginalCfeeHooks).GetMethod(prefixName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
if ((object)method2 == null)
{
CfeeLowVersionFixPlugin.Log.LogWarning((object)("Bypass prefix '" + prefixName + "' could not be found."));
return;
}
harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(method2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
CfeeLowVersionFixPlugin.Log.LogInfo((object)("Installed bypass for " + text + "."));
}
}
private static MethodInfo? ResolveGenerateEggLineMethod()
{
if ((object)_generateEggLineMethod != null)
{
return _generateEggLineMethod;
}
Type type = FindType("testModLethalCompany.Patches.CoordinateForEasterEggs", "CoordinateForEasterEggs");
if ((object)type == null)
{
LogMissingGenerateEggLine("CoordinateForEasterEggs type was not found.");
return null;
}
_generateEggLineMethod = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault(delegate(MethodInfo method)
{
if (!string.Equals(method.Name, "GenerateEggLine", StringComparison.Ordinal))
{
return false;
}
ParameterInfo[] parameters = method.GetParameters();
return parameters.Length == 2 && parameters[0].ParameterType == typeof(Vector3) && parameters[1].ParameterType == typeof(bool);
});
if ((object)_generateEggLineMethod == null)
{
LogMissingGenerateEggLine("CoordinateForEasterEggs.GenerateEggLine(Vector3, bool) was not found.");
}
return _generateEggLineMethod;
}
private static Type? FindType(string fullName, string fallbackName)
{
string fallbackName2 = fallbackName;
string fullName2 = fullName;
Type type = AccessTools.TypeByName(fullName2);
if ((object)type != null)
{
return type;
}
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (Assembly assembly in assemblies)
{
try
{
type = assembly.GetType(fullName2, throwOnError: false);
if ((object)type != null)
{
return type;
}
type = assembly.GetTypes().FirstOrDefault((Type candidate) => string.Equals(candidate.Name, fallbackName2, StringComparison.Ordinal));
if ((object)type != null)
{
return type;
}
}
catch (ReflectionTypeLoadException ex)
{
type = ex.Types.FirstOrDefault((Type candidate) => (object)candidate != null && (string.Equals(candidate.FullName, fullName2, StringComparison.Ordinal) || string.Equals(candidate.Name, fallbackName2, StringComparison.Ordinal)));
if ((object)type != null)
{
return type;
}
}
}
return null;
}
private static void LogMissingGenerateEggLine(string message)
{
if (!_loggedGenerateEggLineFailure)
{
_loggedGenerateEggLineFailure = true;
CfeeLowVersionFixPlugin.Log.LogWarning((object)message);
}
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "CFEELowVersionFix";
public const string PLUGIN_NAME = "CFEELowVersionFix";
public const string PLUGIN_VERSION = "0.1.0";
}
}
namespace Asta.CfeeLowVersionFix.Patches
{
[HarmonyPatch(typeof(StunGrenadeItem), "SetExplodeOnThrowClientRpc")]
internal static class StunGrenadeItemSetExplodeOnThrowClientRpcPatch
{
private static void Postfix(StunGrenadeItem __instance)
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
if (__instance != null)
{
bool explodeOnThrow = __instance.explodeOnThrow;
if (!OriginalCfeeHooks.TryGenerateEggLine(((Component)__instance).transform.position, explodeOnThrow))
{
CfeeLowVersionFixPlugin.Log.LogDebug((object)"Skipped local egg line generation because the original method could not be resolved.");
}
}
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
