using System;
using System.Collections;
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.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using Hypick.ExplosivePresents.NetcodePatcher;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
[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 = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("Hypick.ExplosivePresents")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.1.4.0")]
[assembly: AssemblyInformationalVersion("1.1.4+960ff319f7e6a60ad0ebbd89cc21f833f8d7da1c")]
[assembly: AssemblyProduct("ExplosivePresents")]
[assembly: AssemblyTitle("Hypick.ExplosivePresents")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
internal class <Module>
{
static <Module>()
{
}
}
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 Hypick
{
public class NetworkHandler : NetworkBehaviour
{
public static NetworkHandler Instance { get; private set; }
[ServerRpc(RequireOwnership = false)]
public void CustomExplodeMineServerRpc(Vector3 explosionPosition)
{
//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_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
//IL_00f2: Invalid comparison between Unknown and I4
//IL_010f: Unknown result type (might be due to invalid IL or missing references)
//IL_0115: Invalid comparison between Unknown and I4
//IL_0131: 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(3507213930u, val, (RpcDelivery)0);
((FastBufferWriter)(ref val2)).WriteValueSafe(ref explosionPosition);
((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3507213930u, val, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
{
return;
}
NetworkManager networkManager2 = ((NetworkBehaviour)this).NetworkManager;
if (!((Object)(object)networkManager2 == (Object)null) && networkManager2.IsListening)
{
if ((int)base.__rpc_exec_stage == 1 || networkManager2.IsClient || networkManager2.IsHost)
{
}
if ((int)base.__rpc_exec_stage == 1 && (networkManager2.IsServer || networkManager2.IsHost))
{
CustomExplodeMineClientRpc(explosionPosition);
}
}
}
[ClientRpc]
public void CustomExplodeMineClientRpc(Vector3 explosionPosition)
{
//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_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
//IL_00f2: Invalid comparison between Unknown and I4
//IL_010f: Unknown result type (might be due to invalid IL or missing references)
//IL_0115: Invalid comparison between Unknown and I4
//IL_0131: 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 != 2 && (networkManager.IsServer || networkManager.IsHost))
{
ClientRpcParams val = default(ClientRpcParams);
FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(4091570818u, val, (RpcDelivery)0);
((FastBufferWriter)(ref val2)).WriteValueSafe(ref explosionPosition);
((NetworkBehaviour)this).__endSendClientRpc(ref val2, 4091570818u, val, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost))
{
return;
}
NetworkManager networkManager2 = ((NetworkBehaviour)this).NetworkManager;
if (!((Object)(object)networkManager2 == (Object)null) && networkManager2.IsListening)
{
if ((int)base.__rpc_exec_stage == 2 || networkManager2.IsServer || networkManager2.IsHost)
{
}
if ((int)base.__rpc_exec_stage == 2 && (networkManager2.IsClient || networkManager2.IsHost))
{
((MonoBehaviour)this).StartCoroutine(DelayedExplosion(explosionPosition, spawnExplosionEffect: true, Plugin.Config.KillRange, Plugin.Config.DamageRange, Plugin.Config.Delay));
}
}
}
private static IEnumerator DelayedExplosion(Vector3 explosionPosition, bool spawnExplosionEffect = false, float killRange = 1f, float damageRange = 1f, float Delay = 1f)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
Landmine landmine = Resources.FindObjectsOfTypeAll<Landmine>()[0];
GameObject mineAudio = GameObject.Find("SpeakerAudio");
mineAudio.GetComponent<AudioSource>().PlayOneShot(landmine.mineTrigger, 1f);
yield return (object)new WaitForSeconds(Delay);
mineAudio.GetComponent<AudioSource>().PlayOneShot(landmine.mineDetonate, 1f);
Landmine.SpawnExplosion(explosionPosition + Vector3.up, spawnExplosionEffect, killRange, damageRange);
}
public override void OnNetworkSpawn()
{
if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
{
NetworkHandler instance = Instance;
if (instance != null)
{
((Component)instance).gameObject.GetComponent<NetworkObject>().Despawn(true);
}
}
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
}
((NetworkBehaviour)this).OnNetworkSpawn();
}
protected override void __initializeVariables()
{
((NetworkBehaviour)this).__initializeVariables();
}
[RuntimeInitializeOnLoadMethod]
internal static void InitializeRPCS_NetworkHandler()
{
//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
NetworkManager.__rpc_func_table.Add(3507213930u, new RpcReceiveHandler(__rpc_handler_3507213930));
NetworkManager.__rpc_func_table.Add(4091570818u, new RpcReceiveHandler(__rpc_handler_4091570818));
}
private static void __rpc_handler_3507213930(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_0036: 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_0050: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
Vector3 explosionPosition = default(Vector3);
((FastBufferReader)(ref reader)).ReadValueSafe(ref explosionPosition);
target.__rpc_exec_stage = (__RpcExecStage)1;
((NetworkHandler)(object)target).CustomExplodeMineServerRpc(explosionPosition);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
private static void __rpc_handler_4091570818(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_0036: 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_0050: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
Vector3 explosionPosition = default(Vector3);
((FastBufferReader)(ref reader)).ReadValueSafe(ref explosionPosition);
target.__rpc_exec_stage = (__RpcExecStage)2;
((NetworkHandler)(object)target).CustomExplodeMineClientRpc(explosionPosition);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
[MethodImpl(MethodImplOptions.NoInlining)]
protected internal override string __getTypeName()
{
return "NetworkHandler";
}
}
[BepInPlugin("Hypick.ExplosivePresents", "ExplosivePresents", "1.1.3")]
[BepInIncompatibility("LethalPresents")]
[BepInIncompatibility("GiftBoxRevert")]
[BepInIncompatibility("BuffedPresents")]
[BepInIncompatibility("ExplodingPresents")]
public class Plugin : BaseUnityPlugin
{
public static PluginConfig Config;
private readonly Harmony _harmony = new Harmony("Hypick.ExplosivePresents");
public static Plugin Instance { get; set; }
public static ManualLogSource Log => ((BaseUnityPlugin)Instance).Logger;
public Plugin()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected O, but got Unknown
Instance = this;
}
private void Awake()
{
Config = new PluginConfig(((BaseUnityPlugin)this).Config);
NetcodePatcher();
Log.LogInfo((object)"Applying patches...");
_harmony.PatchAll();
Log.LogInfo((object)"Patches applied");
((BaseUnityPlugin)this).Logger.LogInfo((object)"Hypick.ExplosivePresents is fully loaded!");
}
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 Categories
{
public const string Present = "Present";
}
public class PluginConfig
{
public bool ImmediateExplosion;
public float SpawnChance;
public float KillRange;
public float DamageRange;
public float Delay;
public PluginConfig(ConfigFile cfg)
{
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Expected O, but got Unknown
ImmediateExplosion = cfg.Bind<bool>("Present", "ImmediateExplosion", false, "").Value;
SpawnChance = cfg.Bind<float>("Present", "SpawnChance", 10f, new ConfigDescription("Chance of the present exploding", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 100f), Array.Empty<object>())).Value;
KillRange = cfg.Bind<float>("Present", "KillRange", 5.7f, "Explosion kill range").Value;
DamageRange = cfg.Bind<float>("Present", "DamageRange", 6.4f, "Explosion damage range").Value;
Delay = cfg.Bind<float>("Present", "Delay", 0.5f, "Delay before explosion. In seconds").Value;
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "Hypick.ExplosivePresents";
public const string PLUGIN_NAME = "ExplosivePresents";
public const string PLUGIN_VERSION = "1.1.3";
}
}
namespace Hypick.Patches
{
[HarmonyPatch(typeof(GiftBoxItem))]
internal class GiftBoxItemPatch
{
private enum RpcExecStage
{
None,
Server,
Client
}
[HarmonyPatch("OpenGiftBoxServerRpc")]
[HarmonyPrefix]
private static bool OpenGiftBox(GiftBoxItem __instance)
{
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
if (Mathf.Clamp(Plugin.Config.SpawnChance, 0f, 100f) / 100f > Random.Range(0f, 0.99f))
{
NetworkHandler.Instance.CustomExplodeMineServerRpc(((Component)__instance).transform.position);
return OpenGiftBoxCustom(__instance, explosive: true);
}
return OpenGiftBoxCustom(__instance);
}
private static bool OpenGiftBoxCustom(GiftBoxItem __instance, bool explosive = false)
{
//IL_006b: 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_00af: Unknown result type (might be due to invalid IL or missing references)
//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
//IL_0180: Unknown result type (might be due to invalid IL or missing references)
//IL_0185: Unknown result type (might be due to invalid IL or missing references)
//IL_019e: Unknown result type (might be due to invalid IL or missing references)
//IL_01a5: Expected O, but got Unknown
//IL_0315: Unknown result type (might be due to invalid IL or missing references)
//IL_031b: Unknown result type (might be due to invalid IL or missing references)
//IL_0224: Unknown result type (might be due to invalid IL or missing references)
//IL_0229: Unknown result type (might be due to invalid IL or missing references)
//IL_0233: 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_0240: Unknown result type (might be due to invalid IL or missing references)
//IL_0241: Unknown result type (might be due to invalid IL or missing references)
//IL_026e: Unknown result type (might be due to invalid IL or missing references)
//IL_0275: Expected O, but got Unknown
//IL_0277: Unknown result type (might be due to invalid IL or missing references)
//IL_0278: Unknown result type (might be due to invalid IL or missing references)
//IL_0296: Unknown result type (might be due to invalid IL or missing references)
//IL_029b: Unknown result type (might be due to invalid IL or missing references)
//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)__instance).NetworkManager;
if ((Object)(object)networkManager == (Object)null || !networkManager.IsListening)
{
return false;
}
if ((RpcExecStage)((object)__instance).GetType().GetField("__rpc_exec_stage", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(__instance) != RpcExecStage.Server && (networkManager.IsClient || networkManager.IsHost))
{
ServerRpcParams val = default(ServerRpcParams);
FastBufferWriter val2 = (FastBufferWriter)((object)__instance).GetType().GetMethod("__beginSendServerRpc", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(__instance, new object[3]
{
2878544999u,
val,
(object)(RpcDelivery)0
});
((object)__instance).GetType().GetMethod("__endSendServerRpc", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(__instance, new object[4]
{
val2,
2878544999u,
val,
(object)(RpcDelivery)0
});
}
if ((RpcExecStage)((object)__instance).GetType().GetField("__rpc_exec_stage", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(__instance) != RpcExecStage.Server || (!networkManager.IsClient && !networkManager.IsHost))
{
return false;
}
if (explosive)
{
Plugin.Log.LogInfo((object)"OPEN GIFTBOX WTTH BOMB AHAHAAHAAH");
__instance.OpenGiftBoxNoPresentClientRpc();
return false;
}
Plugin.Log.LogInfo((object)"OPEN GIFTBOX without bomb :(");
GameObject val3 = null;
int num = 0;
Vector3 val4 = Vector3.zero;
GameObject val5 = (GameObject)((object)__instance).GetType().GetField("objectInPresent", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(__instance);
if ((Object)(object)val5 == (Object)null)
{
Debug.LogError((object)"Error: There is no object in gift box!");
}
else
{
Transform val6 = ((((!((Object)(object)((GrabbableObject)__instance).playerHeldBy != (Object)null) || !((GrabbableObject)__instance).playerHeldBy.isInElevator) && !StartOfRound.Instance.inShipPhase) || !((Object)(object)RoundManager.Instance.spawnedScrapContainer != (Object)null)) ? StartOfRound.Instance.elevatorTransform : RoundManager.Instance.spawnedScrapContainer);
val4 = ((Component)__instance).transform.position + Vector3.up * 0.25f;
val3 = Object.Instantiate<GameObject>(val5, val4, Quaternion.identity, val6);
GrabbableObject component = val3.GetComponent<GrabbableObject>();
PlayerControllerB val7 = (PlayerControllerB)((object)__instance).GetType().GetField("previousPlayerHeldBy", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(__instance);
component.startFallingPosition = val4;
((MonoBehaviour)__instance).StartCoroutine(__instance.SetObjectToHitGroundSFX(component));
component.targetFloorPosition = component.GetItemFloorPosition(((Component)__instance).transform.position);
if ((Object)(object)val7 != (Object)null && val7.isInHangarShipRoom)
{
val7.SetItemInElevator(true, true, component);
}
num = (int)((object)__instance).GetType().GetField("objectInPresentValue", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(__instance);
component.SetScrapValue(num);
((NetworkBehaviour)component).NetworkObject.Spawn(false);
}
if ((Object)(object)val3 != (Object)null)
{
__instance.OpenGiftBoxClientRpc(NetworkObjectReference.op_Implicit(val3.GetComponent<NetworkObject>()), num, val4);
}
__instance.OpenGiftBoxNoPresentClientRpc();
return false;
}
}
[HarmonyPatch]
public class NetworkObjectManager
{
private static GameObject networkPrefab;
[HarmonyPostfix]
[HarmonyPatch(typeof(GameNetworkManager), "Start")]
public static void Init()
{
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Expected O, but got Unknown
if (!((Object)(object)networkPrefab != (Object)null))
{
string text = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Assets/netcodemod");
AssetBundle val = ((!File.Exists(text)) ? AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "netcodemod")) : AssetBundle.LoadFromFile(text));
Plugin.Log.LogInfo((object)$"Loading NetworkManager Prefab: {val}");
networkPrefab = (GameObject)val.LoadAsset("Assets/Necode/NetwordManager.prefab");
networkPrefab.AddComponent<NetworkHandler>();
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 System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
namespace Hypick.ExplosivePresents.NetcodePatcher
{
[AttributeUsage(AttributeTargets.Module)]
internal class NetcodePatchedAssemblyAttribute : Attribute
{
}
}
