using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using FishNet;
using FishNet.Broadcast;
using FishNet.Connection;
using FishNet.Managing;
using FishNet.Object;
using FishNet.Serializing;
using FishNet.Transporting;
using HarmonyLib;
using UnityEngine;
using UnityEngine.SceneManagement;

[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("sharko")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Turns the shotgun into an impact dynamite launcher.")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+3a4d4b112dfa7424cb1e60491d109288c41f0174")]
[assembly: AssemblyProduct("GrenadesShotgun")]
[assembly: AssemblyTitle("GrenadesShotgun")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace GrenadesShotgun;

[BepInPlugin("sharko.grenadesshotgun", "GrenadesShotgun", "1.4.0")]
public sealed class Plugin : BaseUnityPlugin
{
	public const string Guid = "sharko.grenadesshotgun";

	public const string Name = "GrenadesShotgun";

	public const string Version = "1.4.0";

	private const int Protocol = 140;

	private const float LaunchSpeed = 22f;

	private const int BaseDamage = 35;

	private const int MaxDamage = 800;

	private const int MaxPlayableUpgradeLevel = 6;

	private const float Radius = 2.5f;

	private static readonly FieldInfo ExplosionInfoField = AccessTools.Field(typeof(Explosive), "_explosionInfo");

	private static readonly FieldInfo DamageField = AccessTools.Field(typeof(ExplosionInfo), "_damage");

	private static readonly FieldInfo BulletUpgradesField = AccessTools.Field(typeof(Attachments), "_bulletUpgrades");

	private static readonly FieldInfo DamageRadiusField = AccessTools.Field(typeof(ExplosionInfo), "damageRadius");

	private static readonly FieldInfo ForceRadiusField = AccessTools.Field(typeof(ExplosionInfo), "_forceRadius");

	private static readonly FieldInfo ItemForceField = AccessTools.Field(typeof(ExplosionInfo), "_itemForce");

	private static readonly FieldInfo BoatForceField = AccessTools.Field(typeof(ExplosionInfo), "_boatForce");

	private static readonly FieldInfo PlayerForceField = AccessTools.Field(typeof(ExplosionInfo), "_playerForce");

	private static Plugin _instance;

	private Harmony _harmony;

	private Item _dynamitePrefab;

	private NetworkManager _network;

	private readonly HashSet<int> _confirmedClients = new HashSet<int>();

	private bool _networkReady;

	private bool _serverState;

	private bool _helloSent;

	private float _nextCheck;

	private void Awake()
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Expected O, but got Unknown
		_instance = this;
		RegisterSerializers();
		_harmony = new Harmony("sharko.grenadesshotgun");
		Patch("AddProjectile", "ReplaceSingle");
		Patch("AddProjectiles", "ReplacePellets");
		((BaseUnityPlugin)this).Logger.LogInfo((object)"GrenadesShotgun loaded - sharko");
	}

	private void Update()
	{
		TryHookNetwork();
		if (!_networkReady)
		{
			return;
		}
		if (_network.ClientManager.Started && _network.ClientManager.Connection.IsAuthenticated)
		{
			if (!_helloSent)
			{
				_helloSent = true;
				_network.ClientManager.Broadcast<ModHello>(new ModHello
				{
					Protocol = 140
				}, (Channel)0);
			}
		}
		else
		{
			_helloSent = false;
			_serverState = false;
		}
		if (_network.ServerManager.Started && Time.unscaledTime >= _nextCheck)
		{
			_nextCheck = Time.unscaledTime + 0.25f;
			RefreshServerState();
		}
	}

	private void OnDestroy()
	{
		UnhookNetwork();
		if (_harmony != null)
		{
			_harmony.UnpatchSelf();
		}
		if ((Object)(object)_instance == (Object)(object)this)
		{
			_instance = null;
		}
	}

	private static void RegisterSerializers()
	{
		GenericWriter<ModHello>.SetWrite((Action<Writer, ModHello>)WriteHello);
		GenericReader<ModHello>.SetRead((Func<Reader, ModHello>)ReadHello);
		GenericWriter<ModState>.SetWrite((Action<Writer, ModState>)WriteState);
		GenericReader<ModState>.SetRead((Func<Reader, ModState>)ReadState);
		GenericWriter<LaunchRequest>.SetWrite((Action<Writer, LaunchRequest>)WriteLaunchRequest);
		GenericReader<LaunchRequest>.SetRead((Func<Reader, LaunchRequest>)ReadLaunchRequest);
	}

	private static void WriteHello(Writer writer, ModHello value)
	{
		writer.WriteInt32(value.Protocol);
	}

	private static ModHello ReadHello(Reader reader)
	{
		return new ModHello
		{
			Protocol = reader.ReadInt32()
		};
	}

	private static void WriteState(Writer writer, ModState value)
	{
		writer.WriteInt32(value.Protocol);
		writer.WriteBoolean(value.Enabled);
	}

	private static ModState ReadState(Reader reader)
	{
		return new ModState
		{
			Protocol = reader.ReadInt32(),
			Enabled = reader.ReadBoolean()
		};
	}

	private static void WriteLaunchRequest(Writer writer, LaunchRequest value)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		writer.WriteVector3(value.Position);
		writer.WriteVector3(value.Direction);
	}

	private static LaunchRequest ReadLaunchRequest(Reader reader)
	{
		//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_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		return new LaunchRequest
		{
			Position = reader.ReadVector3(),
			Direction = reader.ReadVector3()
		};
	}

	private void TryHookNetwork()
	{
		NetworkManager networkManager = InstanceFinder.NetworkManager;
		if (_networkReady)
		{
			if (Object.op_Implicit((Object)(object)_network) && (Object)(object)_network == (Object)(object)networkManager)
			{
				return;
			}
			UnhookNetwork();
		}
		if (Object.op_Implicit((Object)(object)networkManager))
		{
			_network = networkManager;
			_network.ServerManager.RegisterBroadcast<ModHello>((Action<NetworkConnection, ModHello, Channel>)OnHello, true);
			_network.ServerManager.RegisterBroadcast<LaunchRequest>((Action<NetworkConnection, LaunchRequest, Channel>)OnLaunchRequest, true);
			_network.ClientManager.RegisterBroadcast<ModState>((Action<ModState, Channel>)OnState);
			_network.ServerManager.OnRemoteConnectionState += OnRemoteConnectionState;
			_networkReady = true;
		}
	}

	private void UnhookNetwork()
	{
		if (_networkReady && Object.op_Implicit((Object)(object)_network))
		{
			_network.ServerManager.UnregisterBroadcast<ModHello>((Action<NetworkConnection, ModHello, Channel>)OnHello);
			_network.ServerManager.UnregisterBroadcast<LaunchRequest>((Action<NetworkConnection, LaunchRequest, Channel>)OnLaunchRequest);
			_network.ClientManager.UnregisterBroadcast<ModState>((Action<ModState, Channel>)OnState);
			_network.ServerManager.OnRemoteConnectionState -= OnRemoteConnectionState;
			_networkReady = false;
			_serverState = false;
			_confirmedClients.Clear();
		}
	}

	private void OnHello(NetworkConnection connection, ModHello message, Channel channel)
	{
		if (message.Protocol == 140)
		{
			_confirmedClients.Add(connection.ClientId);
		}
		else
		{
			_confirmedClients.Remove(connection.ClientId);
		}
		RefreshServerState();
	}

	private void OnState(ModState state, Channel channel)
	{
		_serverState = state.Protocol == 140 && state.Enabled;
		((BaseUnityPlugin)this).Logger.LogInfo((object)(_serverState ? "Enabled: every player has the mod." : "Disabled: waiting for every player to have the mod."));
	}

	private void OnLaunchRequest(NetworkConnection connection, LaunchRequest request, Channel channel)
	{
		//IL_006c: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d4: 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)
		//IL_009c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
		if (!_serverState || !_confirmedClients.Contains(connection.ClientId))
		{
			return;
		}
		Player val = FindPlayer(connection);
		if (!Object.op_Implicit((Object)(object)val) || !Object.op_Implicit((Object)(object)val.Holding) || !Object.op_Implicit((Object)(object)val.Holding.HeldItem))
		{
			return;
		}
		Item heldItem = val.Holding.HeldItem;
		Weapon val2 = (Weapon)(object)((heldItem is Weapon) ? heldItem : null);
		if (!IsShotgun(val2))
		{
			return;
		}
		Vector3 normalized = ((Vector3)(ref request.Direction)).normalized;
		if (((Vector3)(ref normalized)).sqrMagnitude < 0.9f)
		{
			return;
		}
		Transform firePoint = val2.Attachments.FirePoint;
		if (Object.op_Implicit((Object)(object)firePoint))
		{
			Vector3 val3 = request.Position - firePoint.position;
			if (((Vector3)(ref val3)).sqrMagnitude > 9f || Vector3.Dot(firePoint.forward, normalized) < 0.35f)
			{
				return;
			}
		}
		Launch(val, val2, request.Position, normalized);
	}

	private void OnRemoteConnectionState(NetworkConnection connection, RemoteConnectionStateArgs args)
	{
		_confirmedClients.Remove(connection.ClientId);
		SetServerState(enabled: false);
		_nextCheck = 0f;
	}

	private void RefreshServerState()
	{
		if (!_networkReady || !_network.ServerManager.Started)
		{
			SetServerState(enabled: false);
			return;
		}
		bool flag = false;
		bool flag2 = true;
		foreach (NetworkConnection value in _network.ServerManager.Clients.Values)
		{
			if (value.IsAuthenticated)
			{
				flag = true;
				if (!_confirmedClients.Contains(value.ClientId))
				{
					flag2 = false;
					break;
				}
			}
		}
		SetServerState(flag && flag2);
	}

	private void SetServerState(bool enabled)
	{
		if (_serverState != enabled)
		{
			_serverState = enabled;
			if (_networkReady && _network.ServerManager.Started)
			{
				_network.ServerManager.Broadcast<ModState>(new ModState
				{
					Protocol = 140,
					Enabled = enabled
				}, true, (Channel)0);
			}
		}
	}

	private void Patch(string originalName, string patchName)
	{
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Expected O, but got Unknown
		MethodInfo methodInfo = AccessTools.Method(typeof(ProjectileManager), originalName, (Type[])null, (Type[])null);
		MethodInfo methodInfo2 = AccessTools.Method(typeof(Plugin), patchName, (Type[])null, (Type[])null);
		if (methodInfo != null && methodInfo2 != null)
		{
			_harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
	}

	private static bool ReplaceSingle(Player owner, WeaponInfo weaponInfo, bool isLocal, Vector3 pos, Vector3 velocity)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: 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)
		if (!IsModdedShot(owner, weaponInfo))
		{
			return true;
		}
		if (!isLocal)
		{
			return SuppressEcho(weaponInfo, pos, velocity);
		}
		return !_instance.HandleLaunch(owner, weaponInfo.Weapon, pos, ((Vector3)(ref velocity)).normalized);
	}

	private static bool ReplacePellets(Player owner, WeaponInfo weaponInfo, bool isLocal, Vector3 pos, Vector3[] velocities)
	{
		//IL_0033: 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_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		if (!IsModdedShot(owner, weaponInfo) || velocities == null || velocities.Length == 0)
		{
			return true;
		}
		if (!isLocal)
		{
			return SuppressEcho(weaponInfo, pos, velocities[0]);
		}
		return !_instance.HandleLaunch(owner, weaponInfo.Weapon, pos, ((Vector3)(ref velocities[0])).normalized);
	}

	private static bool SuppressEcho(WeaponInfo weaponInfo, Vector3 pos, Vector3 direction)
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: 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)
		weaponInfo.Weapon.ShootEffects(false);
		string shootVFX = weaponInfo.ShootVFX;
		Quaternion val = Quaternion.LookRotation(((Vector3)(ref direction)).normalized);
		VFXManager.Play(shootVFX, pos, ((Quaternion)(ref val)).eulerAngles);
		return false;
	}

	private static bool IsModdedShot(Player owner, WeaponInfo info)
	{
		if (!Object.op_Implicit((Object)(object)_instance) || !_instance._serverState || !Object.op_Implicit((Object)(object)owner) || info == null || !Object.op_Implicit((Object)(object)info.Weapon))
		{
			return false;
		}
		return IsShotgun(info.Weapon);
	}

	private static bool IsShotgun(Weapon weapon)
	{
		if (!Object.op_Implicit((Object)(object)weapon))
		{
			return false;
		}
		string text = ((Object)weapon).name.ToLowerInvariant();
		if (!text.Contains("shotgun"))
		{
			return text.Contains("pump");
		}
		return true;
	}

	private bool HandleLaunch(Player owner, Weapon weapon, Vector3 position, Vector3 direction)
	{
		//IL_0027: 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_0070: 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_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: Unknown result type (might be due to invalid IL or missing references)
		if (!_networkReady || !_serverState)
		{
			return false;
		}
		if (_network.ServerManager.Started)
		{
			return Launch(owner, weapon, position, direction);
		}
		if (!_network.ClientManager.Started || !_network.ClientManager.Connection.IsAuthenticated)
		{
			return false;
		}
		_network.ClientManager.Broadcast<LaunchRequest>(new LaunchRequest
		{
			Position = position,
			Direction = ((Vector3)(ref direction)).normalized
		}, (Channel)0);
		return true;
	}

	private static Player FindPlayer(NetworkConnection connection)
	{
		for (int i = 0; i < PlayerManager.Players.Count; i++)
		{
			Player val = PlayerManager.Players[i];
			if (Object.op_Implicit((Object)(object)val) && ((NetworkBehaviour)val).Owner == connection)
			{
				return val;
			}
		}
		return null;
	}

	private bool Launch(Player owner, Weapon weapon, Vector3 fallbackPosition, Vector3 fallbackDirection)
	{
		//IL_002a: 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_002f: 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_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b8: 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_00d7: Unknown result type (might be due to invalid IL or missing references)
		Item dynamite = GetDynamite();
		if (!Object.op_Implicit((Object)(object)dynamite))
		{
			return false;
		}
		Transform firePoint = weapon.Attachments.FirePoint;
		Vector3 val = (Object.op_Implicit((Object)(object)firePoint) ? firePoint.forward : fallbackDirection);
		Vector3 val2 = (Object.op_Implicit((Object)(object)firePoint) ? (firePoint.position + val * 0.4f) : fallbackPosition);
		Item val3 = null;
		bool flag = false;
		try
		{
			val3 = Object.Instantiate<Item>(dynamite, val2, Quaternion.LookRotation(val));
			Explosive component = ((Component)val3).GetComponent<Explosive>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				Object.Destroy((Object)(object)((Component)val3).gameObject);
				return false;
			}
			TuneExplosion(component, GetGrenadeDamage(weapon));
			ImpactDynamite impactDynamite = ((Component)val3).gameObject.AddComponent<ImpactDynamite>();
			impactDynamite.Setup(val3, component, owner, ((Vector3)(ref val)).normalized * 22f);
			((NetworkBehaviour)Server.Instance).Spawn(((Component)val3).gameObject, (NetworkConnection)null, default(Scene));
			flag = true;
			impactDynamite.PushNow();
			return true;
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)("Could not launch dynamite: " + ex.Message));
			if (Object.op_Implicit((Object)(object)val3))
			{
				try
				{
					if (flag)
					{
						((NetworkBehaviour)Server.Instance).Despawn(((Component)val3).gameObject, (DespawnType?)null);
					}
					else
					{
						Object.Destroy((Object)(object)((Component)val3).gameObject);
					}
				}
				catch (Exception ex2)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)("Could not clean up failed dynamite: " + ex2.Message));
				}
			}
			return false;
		}
	}

	private Item GetDynamite()
	{
		if (Object.op_Implicit((Object)(object)_dynamitePrefab))
		{
			return _dynamitePrefab;
		}
		Item val = null;
		Item[] array = Resources.LoadAll<Item>("Items");
		foreach (Item val2 in array)
		{
			if (Object.op_Implicit((Object)(object)val2) && Object.op_Implicit((Object)(object)((Component)val2).GetComponent<Explosive>()))
			{
				if (!Object.op_Implicit((Object)(object)val))
				{
					val = val2;
				}
				if (((Object)val2).name.IndexOf("dynamite", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					_dynamitePrefab = val2;
					break;
				}
			}
		}
		if (!Object.op_Implicit((Object)(object)_dynamitePrefab))
		{
			_dynamitePrefab = val;
		}
		return _dynamitePrefab;
	}

	private static int GetGrenadeDamage(Weapon weapon)
	{
		if (!Object.op_Implicit((Object)(object)weapon) || !Object.op_Implicit((Object)(object)weapon.Attachments))
		{
			return 35;
		}
		if (!(BulletUpgradesField?.GetValue(weapon.Attachments) is BulletUpgrade[] array) || array.Length <= 1)
		{
			return 35;
		}
		float num = Mathf.Clamp01((float)Mathf.Clamp((int)weapon.Attachments.AmmoType, 0, array.Length - 1) / 6f);
		float num2 = num * num;
		return Mathf.RoundToInt(Mathf.Lerp(35f, 800f, num2));
	}

	private static void TuneExplosion(Explosive explosive, int damage)
	{
		object? value = ExplosionInfoField.GetValue(explosive);
		ExplosionInfo val = (ExplosionInfo)((value is ExplosionInfo) ? value : null);
		if (val != null)
		{
			DamageField.SetValue(val, Mathf.Clamp(damage, 35, 800));
			DamageRadiusField.SetValue(val, 2.5f);
			ForceRadiusField.SetValue(val, 3f);
			ItemForceField.SetValue(val, 250f);
			BoatForceField.SetValue(val, 150f);
			PlayerForceField.SetValue(val, 12f);
		}
	}
}
public struct ModHello : IBroadcast
{
	public int Protocol;
}
public struct ModState : IBroadcast
{
	public int Protocol;

	public bool Enabled;
}
public struct LaunchRequest : IBroadcast
{
	public Vector3 Position;

	public Vector3 Direction;
}
public sealed class ImpactDynamite : MonoBehaviour
{
	private const float MinSpinSpeed = 8f;

	private const float MaxSpinSpeed = 20f;

	private Item _item;

	private Explosive _explosive;

	private Player _owner;

	private Vector3 _velocity;

	private Vector3 _spin;

	private float _pushUntil;

	private float _armedAt;

	private bool _exploded;

	public void Setup(Item item, Explosive explosive, Player owner, Vector3 velocity)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: 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_0037: Unknown result type (might be due to invalid IL or missing references)
		_item = item;
		_explosive = explosive;
		_owner = owner;
		_velocity = velocity;
		_spin = Random.onUnitSphere * Random.Range(8f, 20f);
		_armedAt = Time.time + 0.06f;
		_pushUntil = Time.time + 0.14f;
		if (Object.op_Implicit((Object)(object)_item) && Object.op_Implicit((Object)(object)_item.Rig))
		{
			_item.Rig.angularDamping = 0f;
		}
	}

	public void PushNow()
	{
		ApplyVelocity();
		ApplySpin();
	}

	private void FixedUpdate()
	{
		if (!_exploded)
		{
			if (Time.time <= _pushUntil)
			{
				ApplyVelocity();
			}
			ApplySpin();
		}
	}

	private void ApplyVelocity()
	{
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		if (Object.op_Implicit((Object)(object)_item) && Object.op_Implicit((Object)(object)_item.Rig))
		{
			_item.Rig.isKinematic = false;
			_item.Rig.collisionDetectionMode = (CollisionDetectionMode)2;
			_item.Rig.linearVelocity = _velocity;
		}
	}

	private void ApplySpin()
	{
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		if (Object.op_Implicit((Object)(object)_item) && Object.op_Implicit((Object)(object)_item.Rig))
		{
			_item.Rig.angularVelocity = _spin;
		}
	}

	private void OnCollisionEnter(Collision collision)
	{
		if (!_exploded && !(Time.time < _armedAt) && Object.op_Implicit((Object)(object)_explosive) && Object.op_Implicit((Object)(object)Server.Instance) && ((NetworkBehaviour)Server.Instance).IsServerInitialized)
		{
			_exploded = true;
			_explosive.ForceExplode(_owner, true);
		}
	}
}