using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using DanielSteginkUtils.ExternalFiles;
using DanielSteginkUtils.Helpers;
using DanielSteginkUtils.Utilities;
using GlobalSettings;
using HarmonyLib;
using HutongGames.PlayMaker;
using HutongGames.PlayMaker.Actions;
using Microsoft.CodeAnalysis;
using NeedolinArsenal.Helpers;
using Silksong.AssetHelper.ManagedAssets;
using UnityEngine;
[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("NeedolinArsenal")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("2.0.0.0")]
[assembly: AssemblyInformationalVersion("2.0.0+ec69483f7f50ca2c33b3f51df3b29b81bebc5a04")]
[assembly: AssemblyProduct("NeedolinArsenal")]
[assembly: AssemblyTitle("NeedolinArsenal")]
[assembly: NeutralResourcesLanguage("EN")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[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 BepInEx
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class BepInAutoPluginAttribute : Attribute
{
public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace BepInEx.Preloader.Core.Patching
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class PatcherAutoPluginAttribute : Attribute
{
public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace Microsoft.CodeAnalysis
{
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace NeedolinArsenal
{
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("io.github.danielstegink.needolinarsenal", "NeedolinArsenal", "2.0.0")]
public class NeedolinArsenal : BaseUnityPlugin
{
public const string Id = "io.github.danielstegink.needolinarsenal";
internal static NeedolinArsenal Instance { get; private set; }
public static string Name => "NeedolinArsenal";
public static string Version => "2.0.0";
private void Awake()
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
Instance = this;
new Harmony("io.github.danielstegink.needolinarsenal").PatchAll();
Assembly executingAssembly = Assembly.GetExecutingAssembly();
MusicToolHelper.shimasenClip = GetAudioClip.GetAudioClipFromAssembly(executingAssembly, "NeedolinArsenal.Resources.Sakura (Zambolino).wav", false);
MusicToolHelper.countryClip = GetAudioClip.GetAudioClipFromAssembly(executingAssembly, "NeedolinArsenal.Resources.Desert West (Dagored).wav", false);
MusicToolHelper.jazzClip = GetAudioClip.GetAudioClipFromAssembly(executingAssembly, "NeedolinArsenal.Resources.At Ease (Hazelwood).wav", false);
MusicToolHelper.metalClip = GetAudioClip.GetAudioClipFromAssembly(executingAssembly, "NeedolinArsenal.Resources.Leader (Zambolino).wav", false);
if ((Object)(object)MusicToolHelper.shimasenClip == (Object)null)
{
Log("Audio clips not loaded successfully");
}
ArsenalEffects.needlePrefab = ManagedAsset<GameObject>.FromNonSceneAsset("Assets/Prefabs/Hornet Enemies/Pinstress CrossSlash.prefab", "localpoolprefabs_assets_areaswamp.bundle");
ArsenalEffects.trobbioPrefab = ManagedAsset<GameObject>.FromNonSceneAsset("Assets/Prefabs/Heroes/Effects/hero_dazzle_flash.prefab", "localpoolprefabs_assets_shared.bundle");
MusicToolHelper.trobbioAsset = ManagedAsset<AudioClip>.FromNonSceneAsset("Assets/Audio/HornetMusic/Battle/H144-71 WIP Trobbio.wav", "sfxstatic_assets_trobbio.bundle");
((BaseUnityPlugin)this).Logger.LogInfo((object)("Plugin " + Name + " (io.github.danielstegink.needolinarsenal) has loaded!"));
}
internal void Log(string message)
{
((BaseUnityPlugin)this).Logger.LogInfo((object)message);
}
}
}
namespace NeedolinArsenal.Helpers
{
internal static class ArsenalEffects
{
[CompilerGenerated]
private sealed class <Arsenal>d__6 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
private Stopwatch <timer>5__2;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <Arsenal>d__6(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<timer>5__2 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0114: Unknown result type (might be due to invalid IL or missing references)
//IL_011e: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<timer>5__2 = Stopwatch.StartNew();
break;
case 1:
<>1__state = -1;
break;
}
while (continueArsenal)
{
if (GameManager.instance.isPaused)
{
continue;
}
try
{
float num = GetCooldownTime(MusicToolHelper.chosenTool);
if (((ToolBase)Gameplay.MusicianCharmTool).IsEquipped)
{
num /= 1.2f;
}
if ((float)<timer>5__2.ElapsedMilliseconds >= num)
{
switch (MusicToolHelper.chosenTool)
{
case MusicTool.Lifeblood:
GainLifeblood();
break;
case MusicTool.Voltvessel:
SpawnVoltvesselBeam();
break;
case MusicTool.Lantern:
SpawnWisp();
break;
case MusicTool.PinBadge:
((MonoBehaviour)GameManager.instance).StartCoroutine(SpawnNeedleStrike());
break;
case MusicTool.Trobbio1:
case MusicTool.Trobbio2:
((MonoBehaviour)GameManager.instance).StartCoroutine(SpawnFireworks());
break;
}
<timer>5__2 = Stopwatch.StartNew();
}
}
catch (Exception ex)
{
NeedolinArsenal.Instance.Log("Error triggering effect: " + ex.Message + "\n" + ex.StackTrace);
}
<>2__current = (object)new WaitForSeconds(Time.deltaTime);
<>1__state = 1;
return true;
}
isArsenalActive = false;
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 <SpawnFireworks>d__12 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <SpawnFireworks>d__12(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0034: 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_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_00da: 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)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
if (trobbioPrefab == null)
{
NeedolinArsenal.Instance.Log("Trobbio prefab not stored");
return false;
}
trobbioPrefab.Load();
<>2__current = trobbioPrefab.Handle;
<>1__state = 1;
return true;
case 1:
{
<>1__state = -1;
if (trobbioPrefab.Handle.OperationException != null)
{
NeedolinArsenal.Instance.Log($"Error loading asset: {trobbioPrefab.Handle.OperationException}");
return false;
}
List<GameObject> enemies = GetEnemy.GetEnemies(15f);
if (enemies.Count > 0)
{
Transform transform = Extensions.GetRandomElement<GameObject>(enemies).transform;
GameObject obj = ManagedAssetExtensions.InstantiateAsset<GameObject>(trobbioPrefab);
((Object)obj).name = "NeedolinArsenal.TrobbioFirework";
Extensions.SetPositionX(obj.transform, transform.position.x);
Extensions.SetPositionY(obj.transform, transform.position.y);
Object.Destroy((Object)(object)obj.GetComponent<TestGameObjectActivator>());
DamageEnemies component = ((Component)((Component)obj.transform.Find("Trobbio_dazzle_flash")).gameObject.transform.Find("hero_dazzle_flash_damager")).gameObject.GetComponent<DamageEnemies>();
component.damageDealt /= 2;
}
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 <SpawnNeedleStrike>d__11 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <SpawnNeedleStrike>d__11(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0034: 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_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_00da: 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)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
if (needlePrefab == null)
{
NeedolinArsenal.Instance.Log("Cross Slash prefab not stored");
return false;
}
needlePrefab.Load();
<>2__current = needlePrefab.Handle;
<>1__state = 1;
return true;
case 1:
{
<>1__state = -1;
if (needlePrefab.Handle.OperationException != null)
{
NeedolinArsenal.Instance.Log($"Error loading asset: {needlePrefab.Handle.OperationException}");
return false;
}
List<GameObject> enemies = GetEnemy.GetEnemies(15f);
if (enemies.Count > 0)
{
Transform transform = Extensions.GetRandomElement<GameObject>(enemies).transform;
GameObject obj = ManagedAssetExtensions.InstantiateAsset<GameObject>(needlePrefab);
((Object)obj).name = "NeedolinArsenal.NeedleStrike";
Extensions.SetPositionX(obj.transform, transform.position.x);
Extensions.SetPositionY(obj.transform, transform.position.y);
Object.Destroy((Object)(object)obj.GetComponent<TestGameObjectActivator>());
GameObject gameObject = ((Component)obj.transform.Find("Damager1")).gameObject;
gameObject.layer = 17;
Components.RemoveComponent<DamageHero>(gameObject);
gameObject.AddComponent<NeedleStrikeDamage>();
GameObject gameObject2 = ((Component)obj.transform.Find("Damager2")).gameObject;
gameObject2.layer = 17;
Components.RemoveComponent<DamageHero>(gameObject2);
gameObject2.AddComponent<NeedleStrikeDamage>();
}
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();
}
}
internal static bool isArsenalActive;
internal static bool continueArsenal;
private static GameObject? beamPrefab;
internal static ManagedAsset<GameObject>? needlePrefab;
internal static ManagedAsset<GameObject>? trobbioPrefab;
internal static void StartArsenal()
{
if (!isArsenalActive && MusicToolHelper.chosenTool.HasValue)
{
isArsenalActive = true;
continueArsenal = true;
((MonoBehaviour)GameManager.instance).StartCoroutine(Arsenal());
}
}
[IteratorStateMachine(typeof(<Arsenal>d__6))]
private static IEnumerator Arsenal()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <Arsenal>d__6(0);
}
private static float GetCooldownTime(MusicTool? tool)
{
return tool switch
{
MusicTool.Lifeblood => 3000f,
MusicTool.Trobbio2 => 1600f,
MusicTool.Trobbio1 => 2000f,
MusicTool.Lantern => 1500f,
_ => 1000f,
};
}
private static void GainLifeblood()
{
if (PlayerData.instance.GetInt("healthBlue") < 8)
{
EventRegister.SendEvent(EventRegisterEvents.AddBlueHealth, (GameObject)null);
}
}
private static void SpawnVoltvesselBeam()
{
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_008f: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)beamPrefab == (Object)null)
{
beamPrefab = ((SpawnObjectFromGlobalPool)FSMUtility.LocateMyFSM(((SpawnProjectileV2)HeroController.instance.toolsFSM.Fsm.GetState("LR Throw").Actions[4]).Prefab.Value, "Control").Fsm.GetState("Explode").Actions[0]).gameObject.Value;
}
int num = Random.Range(-2, 3);
Transform transform = HeroController.instance.transform;
Vector3 val = default(Vector3);
val.x = transform.position.x + (float)(num * 5);
val.y = transform.position.y;
val.z = transform.position.z;
Vector3 val2 = val;
ObjectPoolExtensions.Spawn(beamPrefab, val2);
}
private static void SpawnWisp()
{
List<GameObject> enemies = GetEnemy.GetEnemies(15f);
if (enemies.Count > 0)
{
HeroWispLantern val = Object.FindAnyObjectByType<HeroWispLantern>();
PlayMakerFSM component = ObjectPoolExtensions.Spawn(ClassIntegrations.GetField<HeroWispLantern, GameObject>(val, "wispPrefab", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic), HeroController.instance.transform).GetComponent<PlayMakerFSM>();
component.FsmVariables.FindFsmGameObject("Target").Value = Extensions.GetRandomElement<GameObject>(enemies);
component.FsmVariables.FindFsmGameObject("Spawner").Value = ((Component)val).gameObject;
}
}
[IteratorStateMachine(typeof(<SpawnNeedleStrike>d__11))]
private static IEnumerator SpawnNeedleStrike()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <SpawnNeedleStrike>d__11(0);
}
[IteratorStateMachine(typeof(<SpawnFireworks>d__12))]
private static IEnumerator SpawnFireworks()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <SpawnFireworks>d__12(0);
}
}
[HarmonyPatch(typeof(FsmState), "OnEnter")]
public static class FsmState_OnEnter
{
[CompilerGenerated]
private sealed class <LoadTrobbioMusic>d__1 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <LoadTrobbioMusic>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0034: 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_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
if (MusicToolHelper.trobbioAsset == null)
{
NeedolinArsenal.Instance.Log("Trobbio prefab not stored");
return false;
}
MusicToolHelper.trobbioAsset.Load();
<>2__current = MusicToolHelper.trobbioAsset.Handle;
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if (MusicToolHelper.trobbioAsset.Handle.OperationException != null)
{
NeedolinArsenal.Instance.Log($"Error loading asset: {MusicToolHelper.trobbioAsset.Handle.OperationException}");
return false;
}
MusicToolHelper.trobbioClip = ManagedAssetExtensions.InstantiateAsset<AudioClip>(MusicToolHelper.trobbioAsset);
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();
}
}
[HarmonyPostfix]
public static void Postfix(FsmState __instance)
{
if (__instance.name.Equals("Try Needolin") && (Object)(object)MusicToolHelper.trobbioClip == (Object)null)
{
((MonoBehaviour)GameManager.instance).StartCoroutine(LoadTrobbioMusic());
}
if (StopArsenal(__instance.Name))
{
ArsenalEffects.continueArsenal = false;
}
if (RestartArsenal(__instance.Name))
{
ArsenalEffects.StartArsenal();
}
}
[IteratorStateMachine(typeof(<LoadTrobbioMusic>d__1))]
private static IEnumerator LoadTrobbioMusic()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <LoadTrobbioMusic>d__1(0);
}
private static bool StopArsenal(string stateName)
{
return new List<string> { "Break Loop", "Cancel Needolin?", "Pass CANCEL", "End Needolin", "Needolin Lock", "Needolin Lock 2", "Needolin Mem In", "Needolin FT In" }.Contains(stateName);
}
private static bool RestartArsenal(string stateName)
{
return new List<string> { "Play Needolin" }.Contains(stateName);
}
}
public enum MusicTool
{
Voltvessel,
Lifeblood,
Lantern,
PinBadge,
Trobbio1,
Trobbio2
}
public static class MusicToolHelper
{
public static MusicTool? chosenTool;
public static AudioClip? metalClip;
public static AudioClip? countryClip;
public static AudioClip? jazzClip;
public static AudioClip? shimasenClip;
internal static ManagedAsset<AudioClip>? trobbioAsset;
internal static AudioClip? trobbioClip;
public static List<MusicTool> GetMusicTools(List<string> equippedTools)
{
List<MusicTool> list = new List<MusicTool>();
if (equippedTools.Contains("Lightning Rod"))
{
list.Add(MusicTool.Voltvessel);
}
if (equippedTools.Contains("Wisp Lantern"))
{
list.Add(MusicTool.Lantern);
}
if (equippedTools.Contains("Lifeblood Syringe"))
{
list.Add(MusicTool.Lifeblood);
}
if (equippedTools.Contains("Pinstress Tool"))
{
list.Add(MusicTool.PinBadge);
}
if (equippedTools.Contains("Dazzle Bind"))
{
list.Add(MusicTool.Trobbio1);
}
if (equippedTools.Contains("Dazzle Bind Upgraded"))
{
list.Add(MusicTool.Trobbio2);
}
return list;
}
public static AudioClip? GetAudioClip(MusicTool? tool)
{
return (AudioClip?)(tool switch
{
MusicTool.Voltvessel => metalClip,
MusicTool.Lantern => countryClip,
MusicTool.Lifeblood => jazzClip,
MusicTool.Trobbio1 => trobbioClip,
MusicTool.Trobbio2 => trobbioClip,
_ => shimasenClip,
});
}
}
public class NeedleStrikeDamage : MonoBehaviour
{
public void OnTriggerEnter2D(Collider2D other)
{
if ((Object)(object)other == (Object)null || ((Component)other).gameObject.layer != 11)
{
return;
}
try
{
DamageEnemy.DealDamage(((Component)other).gameObject.GetComponent<HealthManager>(), PlayerData.instance.nailDamage / 2, (AttackTypes)2, ((Component)this).gameObject);
}
catch
{
}
}
}
[HarmonyPatch(typeof(StartNeedolinAudioLoop), "OnEnter")]
public static class StartNeedolinAudioLoop_OnEnter
{
[HarmonyPrefix]
public static void Prefix(StartNeedolinAudioLoop __instance)
{
if (!((FsmStateAction)__instance).State.Name.Equals("Start Needolin Proper"))
{
return;
}
List<MusicTool> musicTools = MusicToolHelper.GetMusicTools(GetTools.GetEquippedTools());
if (musicTools.Count == 0)
{
if (Needolin.NeedolinFsm != null && (Object)(object)Needolin.DefaultClip != (Object)null)
{
MusicToolHelper.chosenTool = null;
Needolin.ResetAudioClip(Needolin.NeedolinFsm, true, false);
}
return;
}
if (!ArsenalEffects.isArsenalActive)
{
MusicToolHelper.chosenTool = Extensions.GetRandomElement<MusicTool>(musicTools);
}
AudioClip audioClip = MusicToolHelper.GetAudioClip(MusicToolHelper.chosenTool);
if ((Object)(object)audioClip != (Object)null)
{
Needolin.SetNewAudioClip(((FsmStateAction)__instance).Fsm, audioClip, false);
}
ArsenalEffects.StartArsenal();
}
}
}
