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.Logging;
using FishNet.Connection;
using FishNet.Object;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.SceneManagement;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Kalamies")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0")]
[assembly: AssemblyProduct("TNTBait")]
[assembly: AssemblyTitle("TNTBait")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[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 TNTBait
{
[BepInPlugin("kalamies.TNTBait", "TNTBait", "0.1.0")]
public class Plugin : BaseUnityPlugin
{
public const string Guid = "kalamies.TNTBait";
public const string Name = "TNTBait";
public const string Version = "0.1.0";
private static readonly Dictionary<Player, byte> PendingLoads = new Dictionary<Player, byte>();
private static readonly List<Charge> ActiveCharges = new List<Charge>();
private static ManualLogSource _log;
private static Plugin _instance;
private static Coroutine _driver;
private static Item _localCharge;
private static byte? _requestedItemId;
private static bool _sawChargeOnLine;
internal static Item LocalCharge => _localCharge;
internal static ManualLogSource Log => _log;
private void Awake()
{
//IL_0016: 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_0030: Expected O, but got Unknown
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Expected O, but got Unknown
//IL_0059: Expected O, but got Unknown
_instance = this;
_log = ((BaseUnityPlugin)this).Logger;
Harmony val = new Harmony("kalamies.TNTBait");
ApplyPatch(val, typeof(ChangeBaitInputPatch), "the change-bait key will behave normally");
ApplyPatch(val, typeof(ChangeBaitPatch), "charges cannot be loaded");
ApplyPatch(val, typeof(SetHeldItemPatch), "there will be no prompt to attach one");
}
private static void ApplyPatch(Harmony harmony, Type patchType, string consequence)
{
try
{
harmony.CreateClassProcessor(patchType).Patch();
}
catch (Exception ex)
{
_log.LogError((object)("Failed to apply " + patchType.Name + ", so " + consequence + ": " + ex.Message));
}
}
internal static void Load(Player player, byte itemId)
{
PendingLoads[player] = itemId;
StartDriver();
}
internal static void StartDriver()
{
if (_driver == null && Object.op_Implicit((Object)(object)_instance))
{
_driver = ((MonoBehaviour)_instance).StartCoroutine(Drive());
}
}
internal static byte? LoadedItemId(Player player)
{
if (!Object.op_Implicit((Object)(object)player))
{
return null;
}
if (PendingLoads.TryGetValue(player, out var value))
{
return value;
}
foreach (Charge activeCharge in ActiveCharges)
{
if ((Object)(object)activeCharge.Owner == (Object)(object)player && activeCharge.IsArmed)
{
return activeCharge.ItemId;
}
}
return null;
}
internal static FishingRod HeldRod(Player player)
{
Item val = ((Object.op_Implicit((Object)(object)player) && Object.op_Implicit((Object)(object)player.Holding)) ? player.Holding.HeldItem : null);
if (!Object.op_Implicit((Object)(object)val))
{
return null;
}
return val.FishingRod;
}
internal static void NoteLocalRequest(byte itemId)
{
_requestedItemId = itemId;
_sawChargeOnLine = false;
}
private static byte? LocalRequestedItemId()
{
Player localPlayer = Player.LocalPlayer;
if (!Object.op_Implicit((Object)(object)localPlayer))
{
_requestedItemId = null;
_sawChargeOnLine = false;
return null;
}
byte? result = LoadedItemId(localPlayer);
if (result.HasValue)
{
_requestedItemId = null;
return result;
}
if (!_requestedItemId.HasValue)
{
return null;
}
if (Object.op_Implicit((Object)(object)_localCharge))
{
_sawChargeOnLine = true;
}
else if (_sawChargeOnLine)
{
_requestedItemId = null;
}
return _requestedItemId;
}
private static IEnumerator Drive()
{
while (true)
{
try
{
if (Object.op_Implicit((Object)(object)Server.Instance) && ((NetworkBehaviour)Server.Instance).IsServerInitialized)
{
SpawnPendingCharges();
UpdateActiveCharges();
}
else if (PendingLoads.Count > 0 || ActiveCharges.Count > 0)
{
PendingLoads.Clear();
ActiveCharges.Clear();
}
HoldLocalChargeOnHook(LocalRequestedItemId());
}
catch (Exception ex)
{
_log.LogWarning((object)("Skipped a frame: " + ex.Message));
}
if (PendingLoads.Count == 0 && ActiveCharges.Count == 0 && !_requestedItemId.HasValue && !Object.op_Implicit((Object)(object)_localCharge))
{
break;
}
yield return null;
}
_driver = null;
}
private static void SpawnPendingCharges()
{
if (PendingLoads.Count == 0)
{
return;
}
List<Player> list = new List<Player>();
foreach (KeyValuePair<Player, byte> pendingLoad in PendingLoads)
{
Player key = pendingLoad.Key;
if (Object.op_Implicit((Object)(object)key) && !((NetworkBehaviour)key).IsDeinitializing)
{
FishingRod val = HeldRod(key);
if (!Object.op_Implicit((Object)(object)val) || !Object.op_Implicit((Object)(object)val.Bait) || Object.op_Implicit((Object)(object)val.Bait.ServerItemOnBait))
{
continue;
}
Item val2 = GameInfo.IDToItem(pendingLoad.Value);
if (Object.op_Implicit((Object)(object)val2))
{
SpawnCharge(key, val, val2, pendingLoad.Value);
}
else
{
_log.LogWarning((object)$"Item {pendingLoad.Value} is not a spawnable prefab; charge lost.");
}
}
list.Add(key);
}
foreach (Player item in list)
{
PendingLoads.Remove(item);
}
}
private static void SpawnCharge(Player owner, FishingRod rod, Item prefab, byte itemId)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: 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_0052: Unknown result type (might be due to invalid IL or missing references)
Bait bait = rod.Bait;
Item val = Object.Instantiate<Item>(prefab, ((Component)bait).transform.position, Quaternion.identity);
val.LastPlayer = owner;
bait.AddItemOnBait(val, true);
val.RigidbodySync.ServerSetSyncedSimulator(((NetworkBehaviour)owner).Owner);
((NetworkBehaviour)CreatureManager.Instance).Spawn(((Component)val).gameObject, (NetworkConnection)null, default(Scene));
ActiveCharges.Add(new Charge(owner, rod, val, itemId));
}
private static void UpdateActiveCharges()
{
for (int num = ActiveCharges.Count - 1; num >= 0; num--)
{
if (!ActiveCharges[num].Tick())
{
ActiveCharges.RemoveAt(num);
}
}
}
private static void HoldLocalChargeOnHook(byte? loadedItemId)
{
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
//IL_00df: Unknown result type (might be due to invalid IL or missing references)
//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
FishingRod val = HeldRod(Player.LocalPlayer);
Bait val2 = (Object.op_Implicit((Object)(object)val) ? val.Bait : null);
if (!Object.op_Implicit((Object)(object)val2))
{
_localCharge = null;
return;
}
if (!Object.op_Implicit((Object)(object)_localCharge) || ((NetworkBehaviour)_localCharge).IsDeinitializing)
{
_localCharge = (loadedItemId.HasValue ? FindChargeOnBait(val2, loadedItemId.Value) : null);
if (!Object.op_Implicit((Object)(object)_localCharge))
{
return;
}
_localCharge.RigidbodySync.StartSimulateLocal(default(Vector3), default(Quaternion));
}
Transform val3 = (Object.op_Implicit((Object)(object)val2.HookTarget) ? val2.HookTarget : ((Component)val2).transform);
((Component)_localCharge).transform.position = val3.position;
Rigidbody rig = _localCharge.Rig;
if (Object.op_Implicit((Object)(object)rig) && !rig.isKinematic)
{
rig.linearVelocity = Vector3.zero;
rig.angularVelocity = Vector3.zero;
}
}
private static Item FindChargeOnBait(Bait bait, byte itemId)
{
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: 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_0060: Unknown result type (might be due to invalid IL or missing references)
foreach (Item value in ItemManager.Items.Values)
{
if (Object.op_Implicit((Object)(object)value) && Object.op_Implicit((Object)(object)value.Explosive) && !Object.op_Implicit((Object)(object)value.SyncedHolder) && value.ID == itemId)
{
Vector3 val = ((Component)value).transform.position - ((Component)bait).transform.position;
if (((Vector3)(ref val)).sqrMagnitude <= 4f)
{
return value;
}
}
}
return null;
}
}
[HarmonyPatch(typeof(PlayerInventory), "ChangeBaitInput")]
internal static class ChangeBaitInputPatch
{
private static bool Prefix(PlayerInventory __instance)
{
try
{
Player val = (Object.op_Implicit((Object)(object)__instance) ? __instance._player : null);
Item val2 = ((Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)val.Holding)) ? val.Holding.HeldItem : null);
ExplosionInfo val3 = ((Object.op_Implicit((Object)(object)val2) && Object.op_Implicit((Object)(object)val2.Explosive)) ? val2.GetExplosionInfo() : null);
if (val3 == null || !val3.HasUnderwaterExplosion)
{
return true;
}
if (val.BlockInputs || Boat.IsDrivingLocally || Boat.WantToDrive)
{
return true;
}
if (!Object.op_Implicit((Object)(object)Server.Instance) || !Object.op_Implicit((Object)(object)val.Inventory))
{
return true;
}
Server.Instance.ChangeBait(val, val.Inventory.CurBait);
Plugin.NoteLocalRequest(val2.ID);
AttachPrompt.Hide();
Plugin.StartDriver();
return false;
}
catch (Exception ex)
{
Plugin.Log.LogWarning((object)("Could not request a charge: " + ex.Message));
return true;
}
}
}
[HarmonyPatch(typeof(Server), "RpcLogic___ChangeBait___1382779195")]
internal static class ChangeBaitPatch
{
private static void Postfix(Player __0, byte __1)
{
byte b = __1;
try
{
if (!Object.op_Implicit((Object)(object)Server.Instance) || !((NetworkBehaviour)Server.Instance).IsServerInitialized || !Object.op_Implicit((Object)(object)__0) || ((NetworkBehaviour)__0).IsDeinitializing || !Object.op_Implicit((Object)(object)__0.Inventory) || b != __0.Inventory.CurBait || Plugin.LoadedItemId(__0).HasValue)
{
return;
}
Item val = (Object.op_Implicit((Object)(object)__0.Holding) ? __0.Holding.HeldItem : null);
if (Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)val.Explosive) && !((Object)(object)val.SyncedHolder != (Object)(object)__0))
{
ExplosionInfo explosionInfo = val.GetExplosionInfo();
if (explosionInfo != null && explosionInfo.HasUnderwaterExplosion)
{
byte iD = val.ID;
val.DestroyItem((byte)7, byte.MaxValue);
Plugin.Load(__0, iD);
}
}
}
catch (Exception ex)
{
Plugin.Log.LogWarning((object)("Could not load a charge: " + ex.Message));
}
}
}
internal sealed class Charge
{
private const float MinimumCastDistance = 3f;
private const float MinimumDepth = 0.2f;
private const float GatherWindow = 2.5f;
private const float GatherRadius = 9f;
private const float PullStrength = 9f;
private const float MaximumTowSpeed = 18f;
private const float TrailDistance = 0.6f;
private const float SlotSpacingRadians = 2.4f;
private const float SlotBaseRadius = 0.35f;
private const float SlotRadiusStep = 0.06f;
private readonly Player _owner;
private readonly FishingRod _rod;
private readonly List<(Item Item, int Slot)> _haul = new List<(Item, int)>();
private Item _charge;
private Item _hookedCatch;
private Vector3 _blastCentre;
private float _detonatedAt;
private int _nextSlot;
internal Player Owner => _owner;
internal byte ItemId { get; }
internal bool IsArmed => _detonatedAt == 0f;
internal Charge(Player owner, FishingRod rod, Item charge, byte itemId)
{
_owner = owner;
_rod = rod;
_charge = charge;
ItemId = itemId;
}
internal bool Tick()
{
if (!Object.op_Implicit((Object)(object)_rod) || (Object)(object)Plugin.HeldRod(_owner) != (Object)(object)_rod)
{
Retire();
return false;
}
Bait bait = _rod.Bait;
if (IsArmed)
{
if (!Object.op_Implicit((Object)(object)_charge) || ((NetworkBehaviour)_charge).IsDeinitializing)
{
Retire();
return false;
}
if (HasLanded())
{
Detonate(bait);
}
return true;
}
if (Time.time - _detonatedAt < 2.5f)
{
GatherCatches(bait);
}
TowCatches(bait);
if (HaulIsStillOnTheLine())
{
return true;
}
Retire();
return false;
}
private bool HasLanded()
{
//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_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: 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)
Vector3 position = ((Component)_charge).transform.position;
if (position.y > WaterManager.GetWaterHeight(position) - 0.2f)
{
return false;
}
Transform val = (Object.op_Implicit((Object)(object)_owner) ? _owner.Transform : null);
if (!Object.op_Implicit((Object)(object)val))
{
return true;
}
Vector3 val2 = position - val.position;
return ((Vector3)(ref val2)).sqrMagnitude > 9f;
}
private void Detonate(Bait bait)
{
//IL_000c: 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)
_blastCentre = ((Component)_charge).transform.position;
_detonatedAt = Time.time;
ExplosionManager instance = ExplosionManager.Instance;
List<ItemInfoWeight> list = (Object.op_Implicit((Object)(object)instance) ? LureTable() : null);
List<ItemInfoWeight> explodabaleItemWeights = ((list != null) ? instance._explodabaleItemWeights : null);
try
{
if (list != null)
{
instance._explodabaleItemWeights = list;
}
ExplosionManager.ServerExplode(_charge, _charge.GetExplosionInfo());
}
catch (Exception ex)
{
Plugin.Log.LogWarning((object)("Charge failed to detonate: " + ex.Message));
}
finally
{
if (list != null)
{
instance._explodabaleItemWeights = explodabaleItemWeights;
}
}
if (Object.op_Implicit((Object)(object)bait))
{
bait.AddItemOnBait((Item)null, true);
}
_charge = null;
}
private List<ItemInfoWeight> LureTable()
{
BaitInfo curBait = _rod.GetCurBait();
if (!Object.op_Implicit((Object)(object)curBait) || curBait.ItemWeights == null)
{
return null;
}
CreatureManager instance = CreatureManager.Instance;
List<ItemInfoWeight> list = new List<ItemInfoWeight>();
foreach (ItemInfoWeight itemWeight in curBait.ItemWeights)
{
if (itemWeight != null && Object.op_Implicit((Object)(object)itemWeight.Fishable) && (!Object.op_Implicit((Object)(object)instance) || !instance.FishableIsBoss(itemWeight.Fishable)))
{
list.Add(itemWeight);
}
}
if (list.Count <= 0)
{
return null;
}
return list;
}
private void GatherCatches(Bait bait)
{
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: 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_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
foreach (Item value in ItemManager.Items.Values)
{
if (!CanBeHauled(value) || AlreadyHauling(value))
{
continue;
}
Vector3 val = ((Component)value).transform.position - _blastCentre;
if (!(((Vector3)(ref val)).sqrMagnitude > 81f))
{
_haul.Add((value, _nextSlot++));
RigidbodySync rigidbodySync = value.RigidbodySync;
val = default(Vector3);
rigidbodySync.StartSimulateLocal(val, default(Quaternion));
if (!Object.op_Implicit((Object)(object)_hookedCatch) && Object.op_Implicit((Object)(object)bait) && !Object.op_Implicit((Object)(object)bait.ServerItemOnBait))
{
HookCatch(value, bait);
}
}
}
}
private bool AlreadyHauling(Item item)
{
foreach (var item2 in _haul)
{
if ((Object)(object)item2.Item == (Object)(object)item)
{
return true;
}
}
return false;
}
private void HookCatch(Item item, Bait bait)
{
item.SetAttachedRod(_rod);
bait.AddItemOnBait(item, true);
item.RigidbodySync.ServerSetSyncedSimulator(((NetworkBehaviour)_owner).Owner);
_hookedCatch = item;
}
private void TowCatches(Bait bait)
{
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
//IL_00a9: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: 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_00e3: Unknown result type (might be due to invalid IL or missing references)
Transform val = ((!Object.op_Implicit((Object)(object)bait)) ? null : (Object.op_Implicit((Object)(object)bait.HookTarget) ? bait.HookTarget : ((Component)bait).transform));
if (!Object.op_Implicit((Object)(object)val))
{
return;
}
for (int num = _haul.Count - 1; num >= 0; num--)
{
var (val2, slot) = _haul[num];
if (!((Object)(object)val2 == (Object)(object)_hookedCatch))
{
if (!CanBeHauled(val2))
{
_haul.RemoveAt(num);
}
else
{
Rigidbody rig = val2.Rig;
if (Object.op_Implicit((Object)(object)rig) && !rig.isKinematic)
{
Vector3 val3 = (val.position + SlotOffset(slot) - Vector3.up * 0.6f - rig.position) * 9f;
rig.linearVelocity = Vector3.ClampMagnitude(val3, 18f);
}
}
}
}
}
private static Vector3 SlotOffset(int slot)
{
//IL_0029: 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)
float num = (float)slot * 2.4f;
float num2 = 0.35f + (float)slot * 0.06f;
return new Vector3(Mathf.Cos(num), 0f, Mathf.Sin(num)) * num2;
}
private bool HaulIsStillOnTheLine()
{
if (Object.op_Implicit((Object)(object)_hookedCatch))
{
if ((Object)(object)_hookedCatch.AttachedRod == (Object)(object)_rod && !Object.op_Implicit((Object)(object)_hookedCatch.SyncedHolder))
{
return !_hookedCatch.IsInInventory;
}
return false;
}
if (_haul.Count <= 0)
{
return Time.time - _detonatedAt < 2.5f;
}
return true;
}
private void Retire()
{
if (Object.op_Implicit((Object)(object)_charge) && !((NetworkBehaviour)_charge).IsDeinitializing)
{
try
{
_charge.DestroyItem((byte)7, byte.MaxValue);
}
catch (Exception ex)
{
Plugin.Log.LogWarning((object)("Could not destroy an undetonated charge: " + ex.Message));
}
}
_charge = null;
_haul.Clear();
}
private static bool CanBeHauled(Item item)
{
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
if (Object.op_Implicit((Object)(object)item) && !((NetworkBehaviour)item).IsDeinitializing && !item.IsDestroying && Object.op_Implicit((Object)(object)item.Creature) && item.Creature.IsDead && (int)item.Creature.BossType == 0 && !Object.op_Implicit((Object)(object)item.AttachedRod) && !Object.op_Implicit((Object)(object)item.BirdHolder) && !Object.op_Implicit((Object)(object)item.SyncedHolder))
{
return !item.IsInInventory;
}
return false;
}
}
internal static class AttachPrompt
{
private const float FadeSeconds = 0.25f;
private static bool _showing;
internal static void Show()
{
//IL_0036: 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)
TextMeshProUGUI val = InfoLine();
string text = PromptText();
if (Object.op_Implicit((Object)(object)val) && text != null)
{
((TMP_Text)val).text = text;
_showing = true;
LeanTween.cancel(((Component)val).gameObject);
((TMP_Text)val).transform.localScale = Vector3.zero;
LeanTween.scale(((Component)val).gameObject, Vector3.one, 0.25f).setEase((LeanTweenType)27);
}
}
internal static void Hide()
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
TextMeshProUGUI val = InfoLine();
if (_showing && Object.op_Implicit((Object)(object)val))
{
_showing = false;
LeanTween.cancel(((Component)val).gameObject);
LeanTween.scale(((Component)val).gameObject, Vector3.zero, 0.25f).setEase((LeanTweenType)26);
}
}
private static TextMeshProUGUI InfoLine()
{
ItemUI val = (Object.op_Implicit((Object)(object)PlayerUI._instance) ? PlayerUI._instance._itemUI : null);
if (!Object.op_Implicit((Object)(object)val))
{
return null;
}
return val._itemInfoText;
}
private static string PromptText()
{
if (!Object.op_Implicit((Object)(object)GameInfo.Input))
{
return null;
}
InputAction val = GameInfo.Input.actions["ChangeBait"];
string text = ((val != null) ? SpriteManager.InputToSpriteName(val, (InputSchemeSelection)0, -1) : null);
if (!string.IsNullOrEmpty(text))
{
return "Attach to bait " + text;
}
return "Attach to bait";
}
}
[HarmonyPatch(typeof(PlayerHolding), "SetHeldItem")]
internal static class SetHeldItemPatch
{
private static void Postfix(PlayerHolding __instance, Item item)
{
try
{
if (Object.op_Implicit((Object)(object)__instance) && !((Object)(object)__instance._player != (Object)(object)Player.LocalPlayer))
{
ExplosionInfo val = ((Object.op_Implicit((Object)(object)item) && Object.op_Implicit((Object)(object)item.Explosive)) ? item.GetExplosionInfo() : null);
if (val != null && val.HasUnderwaterExplosion)
{
AttachPrompt.Show();
}
else
{
AttachPrompt.Hide();
}
}
}
catch (Exception ex)
{
Plugin.Log.LogWarning((object)("Could not update the attach prompt: " + ex.Message));
}
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
