using System;
using System.Collections;
using System.Collections.Generic;
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.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
[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("SuperLandmine")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("SuperLandmine mod for Lethal Company")]
[assembly: AssemblyFileVersion("1.1.7.0")]
[assembly: AssemblyInformationalVersion("1.1.7+63d4043842ea53f4b2be900ec1709592b2118b71")]
[assembly: AssemblyProduct("SuperLandmine")]
[assembly: AssemblyTitle("SuperLandmine")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.7.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;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class ExtensionMarkerAttribute : Attribute
{
private readonly string <Name>k__BackingField;
public string Name => <Name>k__BackingField;
public ExtensionMarkerAttribute(string name)
{
<Name>k__BackingField = name;
}
}
}
namespace SuperLandmine
{
[BepInPlugin("Superlandmine", "SuperLandmine", "1.1.4")]
public class Plugin : BaseUnityPlugin
{
internal static ManualLogSource log;
public Harmony harmony = new Harmony("Superlandmine");
public static ConfigEntry<int> config_LandmineMinAmount;
public static ConfigEntry<int> config_LandmineMaxAmount;
public static ConfigEntry<bool> config_DisableLandmineBeepSound;
public static ConfigEntry<bool> config_DisableLandmineExplosionSound;
public static ConfigEntry<bool> config_EnemyCanTriggerLandmine;
public static ConfigEntry<bool> config_LandmineCanSpawnOutside;
public static ConfigEntry<bool> config_UseDefaultLandmineSpawnRate;
private void Awake()
{
log = ((BaseUnityPlugin)this).Logger;
log.LogInfo((object)"Loading plugin SuperLandmine ...");
ConfigSetup();
harmony.PatchAll();
log.LogInfo((object)"Plugin SuperLandmine loaded!");
}
private void ConfigSetup()
{
config_LandmineMinAmount = ((BaseUnityPlugin)this).Config.Bind<int>("Landmine min amount", "Value", 10, "Min landmine to be spawned in the map");
config_LandmineMaxAmount = ((BaseUnityPlugin)this).Config.Bind<int>("Landmine max amount", "Value", 15, "Max landmine to be spawned in the map");
config_DisableLandmineBeepSound = ((BaseUnityPlugin)this).Config.Bind<bool>("Disable landmine beep sound", "Value", true, "Enable or disable landmine beep sound");
config_DisableLandmineExplosionSound = ((BaseUnityPlugin)this).Config.Bind<bool>("Disable landmine explosion sound", "Value", true, "Enable or disable landmine explosion sound");
config_EnemyCanTriggerLandmine = ((BaseUnityPlugin)this).Config.Bind<bool>("Enemy trigger landmine", "Value", true, "Enable or disable enemy can trigger landmine");
config_LandmineCanSpawnOutside = ((BaseUnityPlugin)this).Config.Bind<bool>("Landmine can spawn outside", "Value", true, "Enable or disable landmine can spawn outside");
config_UseDefaultLandmineSpawnRate = ((BaseUnityPlugin)this).Config.Bind<bool>("Use default landmine spawn rate", "Value", false, "Enable or disable default landmine spawn rate");
}
}
internal static class PluginInfo
{
public const string PLUGIN_GUID = "Superlandmine";
public const string PLUGIN_NAME = "SuperLandmine";
public const string PLUGIN_VERSION = "1.1.4";
}
public static class Utils
{
public class OutsideLandmineMarker : MonoBehaviour
{
}
public const float MAX_RAYCAST_DIST = 30000f;
public static (Vector3, Quaternion) projectToGround(Vector3 position)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//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_000b: 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_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: 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_0028: 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)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
Ray val = new Ray(position, Vector3.down);
Quaternion item = Quaternion.identity;
Vector3 item2 = position;
RaycastHit val2 = default(RaycastHit);
if (Physics.Raycast(val, ref val2, 30000f))
{
item2 = ((RaycastHit)(ref val2)).point;
item = Quaternion.FromToRotation(Vector3.up, ((RaycastHit)(ref val2)).normal);
}
return (item2, item);
}
}
}
namespace SuperLandmine.Patchs
{
[HarmonyPatch(typeof(Landmine))]
public class SuperLandminePatch
{
[CompilerGenerated]
private sealed class <DelayedExplosion>d__6 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public Landmine __instance;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <DelayedExplosion>d__6(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Expected O, but got Unknown
//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
//IL_00db: Unknown result type (might be due to invalid IL or missing references)
//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
//IL_0104: Unknown result type (might be due to invalid IL or missing references)
//IL_010e: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(0.5f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
__instance.mineAudio.volume = 1.2f;
__instance.mineFarAudio.volume = 1.3f;
__instance.mineAudio.pitch = Random.Range(0.93f, 1.07f);
__instance.mineAudio.PlayOneShot(__instance.mineDetonate, 1.2f);
__instance.mineFarAudio.PlayOneShot(__instance.mineDetonate, 1.3f);
Landmine.SpawnExplosion(((Component)__instance).transform.position + Vector3.up, true, 10f, 12f, 50, 0f, (GameObject)null, false);
<>2__current = (object)new WaitForSeconds(0.5f);
<>1__state = 2;
return true;
case 2:
<>1__state = -1;
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <PlayPressSound>d__3 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public Landmine __instance;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <PlayPressSound>d__3(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
//IL_00ae: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
Plugin.log.LogInfo((object)"Play press sound");
__instance.mineAudio.volume = 1.3f;
__instance.mineFarAudio.volume = 1.3f;
__instance.mineAudio.PlayOneShot(__instance.minePress, 1.3f);
WalkieTalkie.TransmitOneShotAudio(__instance.mineAudio, __instance.minePress, 1f);
<>2__current = (object)new WaitForSeconds(__instance.minePress.length);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if (Plugin.config_DisableLandmineBeepSound.Value && !__instance.GetIdleSoundDisabled())
{
__instance.SetIdleSoundDisabled(value: true);
Plugin.log.LogInfo((object)"Disabling idle audio");
__instance.mineAudio.volume = 0f;
__instance.mineFarAudio.volume = 0f;
}
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private static float GetWeightThreshold()
{
if (Chainloader.PluginInfos.ContainsKey("LethalWeightedMines"))
{
object obj = (Type.GetType("LethalWeightedMines.LethalWeightedMines, LethalWeightedMines")?.GetProperty("CustomConfig", BindingFlags.Static | BindingFlags.NonPublic))?.GetValue(null);
if (obj != null)
{
object obj2 = obj.GetType().GetField("MinWeight")?.GetValue(obj);
return (float)((obj2?.GetType().GetProperty("Value"))?.GetValue(obj2) ?? ((object)0.01f));
}
}
return 0.01f;
}
private static float CallGetWeight(Landmine mine)
{
try
{
Type type = Type.GetType("LethalWeightedMines.Patches.LandmineExtender, LethalWeightedMines");
if (type != null)
{
MethodInfo method = type.GetMethod("GetWeight", BindingFlags.Static | BindingFlags.Public);
if (method != null)
{
return (float)method.Invoke(null, new object[1] { mine });
}
}
}
catch (Exception ex)
{
Debug.Log((object)("[SuperLandmines] Reflection failed: " + ex.Message));
}
return 0f;
}
[HarmonyPatch("PressMineClientRpc")]
[HarmonyPostfix]
public static void playTriggerSound(Landmine __instance)
{
Traverse.Create((object)__instance).Field("pressMineDebounceTimer").SetValue((object)0.5f);
((MonoBehaviour)__instance).StartCoroutine(PlayPressSound(__instance));
}
[IteratorStateMachine(typeof(<PlayPressSound>d__3))]
private static IEnumerator PlayPressSound(Landmine __instance)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <PlayPressSound>d__3(0)
{
__instance = __instance
};
}
[HarmonyPatch("SetOffMineAnimation")]
[HarmonyPrefix]
public static void ReEnableAudio(Landmine __instance)
{
__instance.mineAudio.volume = 1.2f;
__instance.mineFarAudio.volume = 1.3f;
}
[HarmonyPatch("Detonate")]
[HarmonyPrefix]
public static void IncreaseAudioVolume(Landmine __instance)
{
Plugin.log.LogInfo((object)"Increase landmine volume and kill range");
__instance.mineAudio.volume = 1.2f;
__instance.mineFarAudio.volume = 1.3f;
if (!__instance.hasExploded)
{
((MonoBehaviour)__instance).StartCoroutine(DelayedExplosion(__instance));
__instance.hasExploded = true;
}
}
[IteratorStateMachine(typeof(<DelayedExplosion>d__6))]
private static IEnumerator DelayedExplosion(Landmine __instance)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <DelayedExplosion>d__6(0)
{
__instance = __instance
};
}
[HarmonyPatch("Detonate")]
[HarmonyPostfix]
public static void disableSoundAfterExplode(Landmine __instance)
{
if (Plugin.config_DisableLandmineExplosionSound.Value)
{
__instance.mineAudio.volume = 0f;
__instance.mineFarAudio.volume = 0f;
}
}
[HarmonyPatch("Start")]
[HarmonyPostfix]
public static void disabledLandMineSound(Landmine __instance)
{
if (Plugin.config_DisableLandmineBeepSound.Value)
{
__instance.mineAudio.volume = 0f;
__instance.mineFarAudio.volume = 0f;
}
}
[HarmonyPatch("OnTriggerEnter")]
[HarmonyPrefix]
public static void anyObjectTriggerLandmineEnter(ref Collider other, Landmine __instance)
{
if (!Plugin.config_EnemyCanTriggerLandmine.Value)
{
return;
}
float weightThreshold = GetWeightThreshold();
float value = Traverse.Create((object)__instance).Field("pressMineDebounceTimer").GetValue<float>();
if (__instance.hasExploded || value > 0f)
{
return;
}
if (((Component)other).CompareTag("Player"))
{
PlayerControllerB component = ((Component)other).gameObject.GetComponent<PlayerControllerB>();
if (!((Object)(object)component != (Object)(object)GameNetworkManager.Instance.localPlayerController) && (Object)(object)component != (Object)null && !component.isPlayerDead)
{
Traverse.Create((object)__instance).Field("localPlayerOnMine").SetValue((object)true);
Traverse.Create((object)__instance).Field("pressMineDebounceTimer").SetValue((object)0.5f);
__instance.PressMineServerRpc();
}
}
else
{
if (!((Component)other).CompareTag("PlayerRagdoll") && !((Component)other).CompareTag("PhysicsProp") && !((Component)other).CompareTag("Enemy"))
{
return;
}
if (Object.op_Implicit((Object)(object)((Component)other).GetComponent<DeadBodyInfo>()))
{
if ((Object)(object)((Component)other).GetComponent<DeadBodyInfo>().playerScript != (Object)(object)GameNetworkManager.Instance.localPlayerController)
{
return;
}
}
else if (Object.op_Implicit((Object)(object)((Component)other).GetComponent<GrabbableObject>()) && !((NetworkBehaviour)((Component)other).GetComponent<GrabbableObject>()).NetworkObject.IsOwner)
{
return;
}
if (CallGetWeight(__instance) >= weightThreshold)
{
Traverse.Create((object)__instance).Field("pressMineDebounceTimer").SetValue((object)0.5f);
__instance.SetIdleSoundDisabled(value: false);
__instance.PressMineServerRpc();
}
}
}
[HarmonyPatch("OnTriggerExit")]
[HarmonyPrefix]
public static void anyObjectTriggerLandmineExit(ref Collider other, Landmine __instance)
{
if (!Plugin.config_EnemyCanTriggerLandmine.Value)
{
return;
}
bool value = Traverse.Create((object)__instance).Field("mineActivated").GetValue<bool>();
float weightThreshold = GetWeightThreshold();
if (__instance.hasExploded || !value)
{
return;
}
if (((Component)other).CompareTag("Player"))
{
PlayerControllerB component = ((Component)other).gameObject.GetComponent<PlayerControllerB>();
if ((Object)(object)component != (Object)null && !component.isPlayerDead && !((Object)(object)component != (Object)(object)GameNetworkManager.Instance.localPlayerController) && !(CallGetWeight(__instance) >= weightThreshold))
{
Traverse.Create((object)__instance).Field("localPlayerOnMine").SetValue((object)false);
Traverse.Create((object)__instance).Method("TriggerMineOnLocalClientByExiting", Array.Empty<object>()).GetValue();
}
}
else
{
if (!((Component)other).CompareTag("PlayerRagdoll") && !((Component)other).CompareTag("PhysicsProp") && !((Component)other).CompareTag("Enemy"))
{
return;
}
if (Object.op_Implicit((Object)(object)((Component)other).GetComponent<DeadBodyInfo>()))
{
if ((Object)(object)((Component)other).GetComponent<DeadBodyInfo>().playerScript != (Object)(object)GameNetworkManager.Instance.localPlayerController)
{
return;
}
}
else if (Object.op_Implicit((Object)(object)((Component)other).GetComponent<GrabbableObject>()) && !((NetworkBehaviour)((Component)other).GetComponent<GrabbableObject>()).NetworkObject.IsOwner)
{
return;
}
if (!(CallGetWeight(__instance) >= weightThreshold))
{
Traverse.Create((object)__instance).Method("TriggerMineOnLocalClientByExiting", Array.Empty<object>()).GetValue();
}
}
}
}
public static class LandmineExtender
{
[SpecialName]
public sealed class <G>$690F5BDD406AC531BEB93458DE0C597F
{
[SpecialName]
public static class <M>$6FA3BD1CE21B404F0D651C26F2C5F6B0
{
}
[ExtensionMarker("<M>$6FA3BD1CE21B404F0D651C26F2C5F6B0")]
public void SetIdleSoundDisabled(bool value)
{
throw new NotSupportedException();
}
[ExtensionMarker("<M>$6FA3BD1CE21B404F0D651C26F2C5F6B0")]
public bool GetIdleSoundDisabled()
{
throw new NotSupportedException();
}
}
private static readonly ConditionalWeakTable<Landmine, LandmineExtension> extension = new ConditionalWeakTable<Landmine, LandmineExtension>();
public static void SetIdleSoundDisabled(this Landmine landmine, bool value)
{
if (!extension.TryGetValue(landmine, out var value2))
{
value2 = new LandmineExtension();
extension.Add(landmine, value2);
}
value2.idleSoundDisabled = value;
}
public static bool GetIdleSoundDisabled(this Landmine landmine)
{
if (extension.TryGetValue(landmine, out var value))
{
return value.idleSoundDisabled;
}
return false;
}
}
public class LandmineExtension
{
public bool idleSoundDisabled { get; set; }
}
[HarmonyPatch(typeof(RoundManager))]
public class RoundManagerPatch
{
[HarmonyPatch("LoadNewLevel")]
[HarmonyPrefix]
public static void spawnLandmineInside(ref SelectableLevel newLevel)
{
//IL_0072: 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_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_00a2: Expected O, but got Unknown
if (Plugin.config_UseDefaultLandmineSpawnRate.Value)
{
return;
}
Plugin.log.LogInfo((object)"Load landmine");
SelectableLevel obj = newLevel;
SpawnableMapObject[] spawnableMapObjects = obj.spawnableMapObjects;
if (obj.spawnableMapObjects.Length == 0)
{
return;
}
Plugin.log.LogInfo((object)"Spawn landmine inside");
SpawnableMapObject[] array = spawnableMapObjects;
foreach (SpawnableMapObject val in array)
{
if ((Object)(object)val.prefabToSpawn.GetComponentInChildren<Landmine>() != (Object)null)
{
val.numberToSpawn = new AnimationCurve((Keyframe[])(object)new Keyframe[2]
{
new Keyframe(0f, (float)Plugin.config_LandmineMinAmount.Value),
new Keyframe(1f, (float)Plugin.config_LandmineMaxAmount.Value)
});
}
}
}
[HarmonyPatch("SpawnOutsideHazards")]
[HarmonyPrefix]
public static void spawnLandmineOutside(RoundManager __instance)
{
//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
//IL_00f7: Expected O, but got Unknown
//IL_014f: Unknown result type (might be due to invalid IL or missing references)
//IL_0154: Unknown result type (might be due to invalid IL or missing references)
//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
//IL_0226: Unknown result type (might be due to invalid IL or missing references)
//IL_0231: Unknown result type (might be due to invalid IL or missing references)
//IL_0236: Unknown result type (might be due to invalid IL or missing references)
//IL_0238: Unknown result type (might be due to invalid IL or missing references)
//IL_023d: Unknown result type (might be due to invalid IL or missing references)
//IL_0246: Unknown result type (might be due to invalid IL or missing references)
//IL_0248: Unknown result type (might be due to invalid IL or missing references)
if (!Plugin.config_LandmineCanSpawnOutside.Value || !((NetworkBehaviour)__instance).IsServer || !((NetworkBehaviour)__instance).IsHost || (Object)(object)__instance.currentLevel == (Object)null)
{
return;
}
Utils.OutsideLandmineMarker[] array = Object.FindObjectsByType<Utils.OutsideLandmineMarker>((FindObjectsSortMode)0);
for (int i = 0; i < array.Length; i++)
{
Object.Destroy((Object)(object)((Component)array[i]).gameObject);
}
Plugin.log.LogInfo((object)"Load landmine");
SpawnableMapObject[] spawnableMapObjects = __instance.currentLevel.spawnableMapObjects;
if (spawnableMapObjects == null || spawnableMapObjects.Length == 0)
{
return;
}
Plugin.log.LogInfo((object)"Spawn landmine outside");
SpawnableMapObject[] array2 = spawnableMapObjects;
foreach (SpawnableMapObject val in array2)
{
if (!((Object)(object)val.prefabToSpawn.GetComponentInChildren<Landmine>() != (Object)null))
{
continue;
}
AnimationCurve val2 = new AnimationCurve((Keyframe[])(object)new Keyframe[2]
{
new Keyframe(0f, (float)Plugin.config_LandmineMinAmount.Value),
new Keyframe(1f, (float)Plugin.config_LandmineMaxAmount.Value)
});
Transform[] shipSpawnPathPoints = __instance.shipSpawnPathPoints;
if (shipSpawnPathPoints == null)
{
break;
}
Transform[] array3 = shipSpawnPathPoints;
foreach (Transform val3 in array3)
{
int num = (int)val2.Evaluate(Random.Range(0f, 1f));
for (int k = 0; k < num; k++)
{
Random random = new Random();
NavMeshHit value = Traverse.Create((object)__instance).Field<NavMeshHit>("navHit").Value;
Type[] array4 = new Type[6]
{
typeof(Vector3),
typeof(float),
typeof(NavMeshHit),
typeof(Random),
typeof(int),
typeof(float)
};
MethodInfo methodInfo = AccessTools.Method(typeof(RoundManager), "GetRandomNavMeshPositionInBoxPredictable", array4, (Type[])null);
if (methodInfo != null)
{
object[] parameters = new object[6] { val3.position, 300f, value, random, -5, 1f };
(Vector3, Quaternion) tuple = Utils.projectToGround((Vector3)methodInfo.Invoke(__instance, parameters));
Vector3 item = tuple.Item1;
Quaternion item2 = tuple.Item2;
GameObject obj = Object.Instantiate<GameObject>(val.prefabToSpawn, item, item2);
obj.SetActive(true);
obj.GetComponent<NetworkObject>().Spawn(false);
obj.AddComponent<Utils.OutsideLandmineMarker>();
}
else
{
Plugin.log.LogError((object)"FAILED TO FIND METHOD: Even with reflection and parameter counting.");
}
}
}
}
}
}
}
