using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LandmineScrapPlugin.NetcodePatcher;
using LandmineScrapPlugin.components;
using LethalLib.Modules;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Events;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = "")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("LandmineScrapPlugin")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Disarm and sell landmines")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("LandmineScrapPlugin")]
[assembly: AssemblyTitle("LandmineScrapPlugin")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: NetcodePatchedAssembly]
internal class <Module>
{
static <Module>()
{
}
}
namespace LandmineScrapPlugin
{
[BepInPlugin("LandmineScrapPlugin", "LandmineScrapPlugin", "1.0.0")]
public class LandmineScrapBase : BaseUnityPlugin
{
private readonly Harmony harmony = new Harmony("LandmineScrapPlugin");
public static LandmineScrapBase Instance;
internal Item landmineScrapItem;
internal GameObject landmineNetworkHandler;
internal ManualLogSource mls;
private void Awake()
{
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
}
NetcodePatcher();
mls = Logger.CreateLogSource("LandmineScrapPlugin");
string text = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "landminemod");
AssetBundle val = AssetBundle.LoadFromFile(text);
if ((Object)(object)val == (Object)null)
{
mls.LogError((object)"Failed to load asset bundle");
return;
}
mls.LogInfo((object)("Asset Bundle Assets: " + GeneralExtensions.Join<string>((IEnumerable<string>)val.GetAllAssetNames(), (Func<string, string>)null, ", ")));
landmineScrapItem = val.LoadAsset<Item>("Assets/LandmineResources/LandmineItem.asset");
landmineNetworkHandler = val.LoadAsset<GameObject>("Assets/LandmineResources/LandmineNetworkHandler.prefab");
if ((Object)(object)landmineScrapItem == (Object)null || (Object)(object)landmineNetworkHandler == (Object)null)
{
mls.LogError((object)"Failed to load custom assets");
return;
}
NetworkPrefabs.RegisterNetworkPrefab(landmineScrapItem.spawnPrefab);
Utilities.FixMixerGroups(landmineScrapItem.spawnPrefab);
Items.RegisterScrap(landmineScrapItem, 0, (LevelTypes)1, (string[])null);
mls.LogInfo((object)"LandmineScrap has awoken!");
harmony.PatchAll();
}
private static void NetcodePatcher()
{
Type[] types = Assembly.GetExecutingAssembly().GetTypes();
Type[] array = types;
foreach (Type type in array)
{
MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
MethodInfo[] array2 = methods;
foreach (MethodInfo methodInfo in array2)
{
object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
if (customAttributes.Length != 0)
{
methodInfo.Invoke(null, null);
}
}
}
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "LandmineScrapPlugin";
public const string PLUGIN_NAME = "LandmineScrapPlugin";
public const string PLUGIN_VERSION = "1.0.0";
}
}
namespace LandmineScrapPlugin.Patches
{
[HarmonyPatch(typeof(Landmine))]
internal class LandminePatch
{
[HarmonyPostfix]
[HarmonyPatch(typeof(Landmine), "Start")]
public static void addInteraction(Landmine __instance)
{
CustomLandmines.addInteractionTrigger(__instance);
}
[HarmonyPostfix]
[HarmonyPatch(typeof(Landmine), "Detonate")]
public static void remove(Landmine __instance)
{
CustomNetworkHandler.Instance.RemoveLandmineServerRPC(((Component)((Component)__instance).transform.parent).GetComponent<NetworkObject>().NetworkObjectId);
}
}
[HarmonyPatch]
public class NetworkObjectManager
{
private static GameObject networkPrefab;
[HarmonyPostfix]
[HarmonyPatch(typeof(GameNetworkManager), "Start")]
public static void Init()
{
if (!((Object)(object)networkPrefab != (Object)null))
{
networkPrefab = LandmineScrapBase.Instance.landmineNetworkHandler;
networkPrefab.AddComponent<CustomNetworkHandler>();
NetworkManager.Singleton.AddNetworkPrefab(networkPrefab);
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(StartOfRound), "Awake")]
private static void SpawnNetworkHandler()
{
//IL_0024: 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)
if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
{
GameObject val = Object.Instantiate<GameObject>(networkPrefab, Vector3.zero, Quaternion.identity);
val.GetComponent<NetworkObject>().Spawn(false);
}
}
}
}
namespace LandmineScrapPlugin.components
{
internal class CustomLandmines
{
public static void addInteractionTrigger(Landmine mine)
{
//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Expected O, but got Unknown
//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
//IL_00cd: Expected O, but got Unknown
//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Expected O, but got Unknown
//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
//IL_00e3: Expected O, but got Unknown
//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
//IL_00ee: Expected O, but got Unknown
GameObject mineObject = ((Component)mine).gameObject;
mineObject.GetComponent<MeshRenderer>();
mineObject.tag = "InteractTrigger";
mineObject.layer = LayerMask.NameToLayer("InteractableObject");
InteractTrigger val = mineObject.AddComponent<InteractTrigger>();
GameObject obj = GameObject.Find("StartGameLever");
val.hoverIcon = ((obj == null) ? null : obj.GetComponent<InteractTrigger>()?.hoverIcon);
val.hoverTip = "Disarm : [LMB]";
val.interactable = true;
val.oneHandedItemAllowed = false;
val.twoHandedItemAllowed = false;
val.holdInteraction = true;
val.timeToHold = 5f;
val.timeToHoldSpeedMultiplier = 1f;
val.holdingInteractEvent = new InteractEventFloat();
val.onInteract = new InteractEvent();
val.onInteractEarly = new InteractEvent();
val.onStopInteract = new InteractEvent();
val.onCancelAnimation = new InteractEvent();
((UnityEvent<PlayerControllerB>)(object)val.onInteract).AddListener((UnityAction<PlayerControllerB>)delegate(PlayerControllerB player)
{
RollDisarm(mineObject, player);
});
val.triggerOnce = true;
}
private static void RollDisarm(GameObject mineObject, PlayerControllerB player)
{
int num = 34;
int num2 = Random.Range(0, 100);
LandmineScrapBase.Instance.mls.LogInfo((object)("Rolled chance: " + num2));
if (num2 <= num)
{
mineObject.GetComponent<Landmine>().ExplodeMineServerRpc();
}
else
{
CustomNetworkHandler.Instance.DeactivateMineServerRPC(((Component)mineObject.transform.parent).GetComponent<NetworkObject>().NetworkObjectId);
}
}
}
public class CustomNetworkHandler : NetworkBehaviour
{
public static CustomNetworkHandler Instance { get; private set; }
public override void OnNetworkSpawn()
{
if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
{
CustomNetworkHandler instance = Instance;
if (instance != null)
{
((Component)instance).gameObject.GetComponent<NetworkObject>().Despawn(true);
}
}
Instance = this;
((NetworkBehaviour)this).OnNetworkSpawn();
}
[ServerRpc(RequireOwnership = false)]
public void DeactivateMineServerRPC(ulong landmineNetworkID)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_0099: Unknown result type (might be due to invalid IL or missing references)
//IL_00a3: Invalid comparison between Unknown and I4
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: 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)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
//IL_011b: Unknown result type (might be due to invalid IL or missing references)
//IL_011c: Unknown result type (might be due to invalid IL or missing references)
//IL_0184: Unknown result type (might be due to invalid IL or missing references)
//IL_0198: Unknown result type (might be due to invalid IL or missing references)
//IL_019d: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager == null || !networkManager.IsListening)
{
return;
}
if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
{
ServerRpcParams val = default(ServerRpcParams);
FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1429377038u, val, (RpcDelivery)0);
BytePacker.WriteValueBitPacked(val2, landmineNetworkID);
((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1429377038u, val, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
{
GameObject gameObject = ((Component)((NetworkBehaviour)this).GetNetworkObject(landmineNetworkID)).gameObject;
Vector3 position = gameObject.transform.position;
ManualLogSource mls = LandmineScrapBase.Instance.mls;
Vector3 val3 = position;
mls.LogInfo((object)("Disarming landmine at " + ((object)(Vector3)(ref val3)).ToString()));
GameObject val4 = Object.Instantiate<GameObject>(LandmineScrapBase.Instance.landmineScrapItem.spawnPrefab, position, Quaternion.identity);
if ((Object)(object)val4 == (Object)null)
{
LandmineScrapBase.Instance.mls.LogError((object)"Failed to instantiate the mine scrap!");
}
val4.GetComponent<NetworkObject>().Spawn(false);
if (!((GrabbableObject)val4.GetComponent<PhysicsProp>()).isInShipRoom && !((GrabbableObject)val4.GetComponent<PhysicsProp>()).isInFactory)
{
Transform transform = val4.transform;
transform.position += new Vector3(0f, 2f, 0f);
}
LandmineScrapBase.Instance.mls.LogInfo((object)"Attempting to destroy landmine!");
Object.Destroy((Object)(object)gameObject);
PhysicsProp component = val4.GetComponent<PhysicsProp>();
int minValue = ((GrabbableObject)component).itemProperties.minValue;
int maxValue = ((GrabbableObject)component).itemProperties.maxValue;
int scrapValue = Random.Range(minValue, maxValue);
SetLandmineScrapValueClientRPC(val4.GetComponent<NetworkObject>().NetworkObjectId, scrapValue);
}
}
[ServerRpc(RequireOwnership = false)]
public void RemoveLandmineServerRPC(ulong landmineNetworkID)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_0099: Unknown result type (might be due to invalid IL or missing references)
//IL_00a3: Invalid comparison between Unknown and I4
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: 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)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
{
ServerRpcParams val = default(ServerRpcParams);
FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1910831513u, val, (RpcDelivery)0);
BytePacker.WriteValueBitPacked(val2, landmineNetworkID);
((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1910831513u, val, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
{
Object.Destroy((Object)(object)((Component)((NetworkBehaviour)this).GetNetworkObject(landmineNetworkID)).gameObject, 5f);
}
}
}
[ClientRpc]
public void SetLandmineScrapValueClientRPC(ulong scrapNetworkID, int scrapValue)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
//IL_00b0: Invalid comparison between Unknown and I4
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: 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)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
{
ClientRpcParams val = default(ClientRpcParams);
FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2412340304u, val, (RpcDelivery)0);
BytePacker.WriteValueBitPacked(val2, scrapNetworkID);
BytePacker.WriteValueBitPacked(val2, scrapValue);
((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2412340304u, val, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
{
GameObject gameObject = ((Component)((NetworkBehaviour)this).GetNetworkObject(scrapNetworkID)).gameObject;
ScanNodeProperties componentInChildren = gameObject.GetComponentInChildren<ScanNodeProperties>();
componentInChildren.scrapValue = scrapValue;
componentInChildren.subText = "Value: $" + scrapValue;
PhysicsProp component = gameObject.GetComponent<PhysicsProp>();
((GrabbableObject)component).scrapValue = scrapValue;
}
}
}
protected override void __initializeVariables()
{
((NetworkBehaviour)this).__initializeVariables();
}
[RuntimeInitializeOnLoadMethod]
internal static void InitializeRPCS_CustomNetworkHandler()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Expected O, but got Unknown
NetworkManager.__rpc_func_table.Add(1429377038u, new RpcReceiveHandler(__rpc_handler_1429377038));
NetworkManager.__rpc_func_table.Add(1910831513u, new RpcReceiveHandler(__rpc_handler_1910831513));
NetworkManager.__rpc_func_table.Add(2412340304u, new RpcReceiveHandler(__rpc_handler_2412340304));
}
private static void __rpc_handler_1429377038(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
ulong landmineNetworkID = default(ulong);
ByteUnpacker.ReadValueBitPacked(reader, ref landmineNetworkID);
target.__rpc_exec_stage = (__RpcExecStage)1;
((CustomNetworkHandler)(object)target).DeactivateMineServerRPC(landmineNetworkID);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
private static void __rpc_handler_1910831513(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
ulong landmineNetworkID = default(ulong);
ByteUnpacker.ReadValueBitPacked(reader, ref landmineNetworkID);
target.__rpc_exec_stage = (__RpcExecStage)1;
((CustomNetworkHandler)(object)target).RemoveLandmineServerRPC(landmineNetworkID);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
private static void __rpc_handler_2412340304(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_0023: 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_0043: 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)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
ulong scrapNetworkID = default(ulong);
ByteUnpacker.ReadValueBitPacked(reader, ref scrapNetworkID);
int scrapValue = default(int);
ByteUnpacker.ReadValueBitPacked(reader, ref scrapValue);
target.__rpc_exec_stage = (__RpcExecStage)2;
((CustomNetworkHandler)(object)target).SetLandmineScrapValueClientRPC(scrapNetworkID, scrapValue);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
protected internal override string __getTypeName()
{
return "CustomNetworkHandler";
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
namespace LandmineScrapPlugin.NetcodePatcher
{
[AttributeUsage(AttributeTargets.Module)]
internal class NetcodePatchedAssemblyAttribute : Attribute
{
}
}
