using System;
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.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using LC_LandminesForAll.Patches;
using LC_LandminesForAll.Utils;
using Microsoft.CodeAnalysis;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("LC_LandminesForAll")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Templete")]
[assembly: AssemblyFileVersion("1.0.1.0")]
[assembly: AssemblyInformationalVersion("1.0.1+d2a1d9af8893c2a3098c4da244d009911438c0a4")]
[assembly: AssemblyProduct("LC_LandminesForAll")]
[assembly: AssemblyTitle("LC_LandminesForAll")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.1.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.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace LC_LandminesForAll
{
public class MyPluginInfo
{
public const string PLUGIN_GUID = "sakura.lc.landminesforall";
public const string PLUGIN_NAME = "LandminesForAll";
public const string PLUGIN_VERSION = "1.0.1";
}
[BepInPlugin("sakura.lc.landminesforall", "LandminesForAll", "1.0.1")]
public class Plugin : BaseUnityPlugin
{
private Harmony _harmony;
internal static ManualLogSource Logger;
public static string ThisPluginFolder => Path.Combine(Paths.PluginPath, "Sakura-LandminesForAll");
private void Awake()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
Logger = ((BaseUnityPlugin)this).Logger;
_harmony = new Harmony("sakura.lc.landminesforall");
_harmony.PatchAll(typeof(LandminePatch));
Logger.LogInfo((object)"Plugin sakura.lc.landminesforall is loaded!");
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "LC_LandminesForAll";
public const string PLUGIN_NAME = "LC_LandminesForAll";
public const string PLUGIN_VERSION = "1.0.1";
}
}
namespace LC_LandminesForAll.Utils
{
internal static class ReflectionUtils
{
public static void SetPrivateField<T>(this T instance, string fieldName, object value)
{
typeof(T).GetField(fieldName, BindingFlags.Instance | BindingFlags.NonPublic).SetValue(instance, value);
}
public static void SetPrivateProperty<T>(this T instance, string propertyName, object value)
{
typeof(T).GetProperty(propertyName, BindingFlags.Instance | BindingFlags.NonPublic).SetValue(instance, value);
}
public static void SetPrivateStaticField<T>(string fieldName, object value)
{
typeof(T).GetField(fieldName, BindingFlags.Static | BindingFlags.NonPublic).SetValue(null, value);
}
public static void SetPrivateStaticProperty<T>(string propertyName, object value)
{
typeof(T).GetProperty(propertyName, BindingFlags.Static | BindingFlags.NonPublic).SetValue(null, value);
}
public static T GetPrivateField<T>(this object instance, string fieldName)
{
return (T)instance.GetType().GetField(fieldName, BindingFlags.Instance | BindingFlags.NonPublic).GetValue(instance);
}
public static T GetPrivateProperty<T>(this object instance, string propertyName)
{
return (T)instance.GetType().GetProperty(propertyName, BindingFlags.Instance | BindingFlags.NonPublic).GetValue(instance);
}
public static T GetPrivateStaticField<T>(string fieldName)
{
return (T)typeof(T).GetField(fieldName, BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
}
public static T GetPrivateStaticProperty<T>(string propertyName)
{
return (T)typeof(T).GetProperty(propertyName, BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
}
public static void InvokePrivateMethod<T>(this T instance, string methodName, params object[] parameters)
{
instance.GetType().GetMethod(methodName, BindingFlags.Instance | BindingFlags.NonPublic).Invoke(instance, parameters);
}
public static void InvokePrivateStaticMethod<T>(string methodName, params object[] parameters)
{
typeof(T).GetMethod(methodName, BindingFlags.Static | BindingFlags.NonPublic).Invoke(null, parameters);
}
public static T CreatePrivateInstance<T>(params object[] parameters)
{
return (T)Activator.CreateInstance(typeof(T), BindingFlags.Instance | BindingFlags.NonPublic, null, parameters, null);
}
public static T CreatePrivateStaticInstance<T>(params object[] parameters)
{
return (T)Activator.CreateInstance(typeof(T), BindingFlags.Static | BindingFlags.NonPublic, null, parameters, null);
}
}
}
namespace LC_LandminesForAll.Patches
{
[HarmonyPatch(typeof(Landmine))]
internal class LandminePatch
{
private const int LineOfSightLayer = 18;
private const int EnemyLayer = 19;
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void Start(Landmine __instance)
{
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: 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_0099: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
BoxCollider val = ((IEnumerable<BoxCollider>)((Component)__instance).GetComponents<BoxCollider>()).FirstOrDefault((Func<BoxCollider, bool>)((BoxCollider x) => ((Collider)x).isTrigger));
if ((Object)(object)val == (Object)null)
{
Plugin.Logger.LogError((object)$"Could not find mine trigger collider on mine at {((Component)__instance).transform.position}");
return;
}
BoxCollider obj = ((Component)__instance).gameObject.AddComponent<BoxCollider>();
((Collider)obj).isTrigger = true;
obj.size = val.size * 2f;
obj.center = val.center;
((Collider)obj).enabled = true;
((Collider)obj).includeLayers = LayerMask.op_Implicit(524288);
}
private static void TriggerDebounce(Landmine __instance)
{
//IL_0017: 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_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
Transform closestEnemyForLogging = GetClosestEnemyForLogging(__instance);
Plugin.Logger.LogDebug((object)$"Triggering debounce on mine at {((Component)__instance).transform.position} with closest enemy at {closestEnemyForLogging.position} at {Vector3.Distance(((Component)__instance).transform.position, ((Component)closestEnemyForLogging).transform.position)} units away.");
__instance.SetPrivateField<Landmine>("pressMineDebounceTimer", 0.5f);
__instance.PressMineServerRpc();
}
private static void TriggerMineExplosion(Landmine __instance)
{
//IL_0017: 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_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
Transform closestEnemyForLogging = GetClosestEnemyForLogging(__instance);
Plugin.Logger.LogDebug((object)$"Triggering debounce on mine at {((Component)__instance).transform.position} with closest enemy at {closestEnemyForLogging.position} at {Vector3.Distance(((Component)__instance).transform.position, ((Component)closestEnemyForLogging).transform.position)} units away.");
__instance.InvokePrivateMethod<Landmine>("TriggerMineOnLocalClientByExiting", Array.Empty<object>());
}
private static Transform GetClosestEnemyForLogging(Landmine __instance)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: 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)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
LayerMask val = LayerMask.op_Implicit(524288);
RaycastHit[] array = Physics.SphereCastAll(((Component)__instance).transform.position, 10000f, Vector3.up, 0f, LayerMask.op_Implicit(val));
Transform result = null;
float num = float.MaxValue;
RaycastHit[] array2 = array;
for (int i = 0; i < array2.Length; i++)
{
RaycastHit val2 = array2[i];
if (((Component)((RaycastHit)(ref val2)).collider).CompareTag("Enemy"))
{
float num2 = Vector3.Distance(((Component)__instance).transform.position, ((RaycastHit)(ref val2)).transform.position);
if (num2 < num)
{
num = num2;
result = ((RaycastHit)(ref val2)).transform;
}
}
}
return result;
}
[HarmonyPatch("OnTriggerEnter")]
[HarmonyPrefix]
private static bool OnTriggerEnter(Landmine __instance, Collider other)
{
if (__instance.hasExploded || __instance.GetPrivateField<float>("pressMineDebounceTimer") > 0f)
{
return true;
}
if (((Component)other).CompareTag("Enemy"))
{
TriggerDebounce(__instance);
return false;
}
return true;
}
[HarmonyPatch("OnTriggerExit")]
[HarmonyPrefix]
private static bool OnTriggerExit(Landmine __instance, Collider other)
{
if (__instance.hasExploded || __instance.GetPrivateField<float>("pressMineDebounceTimer") > 0f)
{
return true;
}
if (((Component)other).CompareTag("Enemy"))
{
TriggerMineExplosion(__instance);
return false;
}
return true;
}
}
}
