Decompiled source of Autocomplete v1.0.1

Mods/Autocomplete.dll

Decompiled a week ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using Autocomplete;
using HarmonyLib;
using MelonLoader;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(Class1), "Autocomplete", "1.0", "TheMrEvil", null)]
[assembly: MelonGame("Alvios", "Vellum")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Autocomplete")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("Autocomplete")]
[assembly: AssemblyTitle("Autocomplete")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
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;
		}
	}
}
namespace Autocomplete
{
	public class Class1 : MelonMod
	{
		[HarmonyPatch(typeof(UIPlayerScroll), "OpenSequence")]
		public class UIPlayerScrollPatch
		{
			[CompilerGenerated]
			private sealed class <FastOpenSequence>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

				public UIPlayerScroll __instance;

				public float delay;

				private float <speedMultiplier>5__2;

				private FieldInfo <isOpeningField>5__3;

				private PropertyInfo <rarityFXProperty>5__4;

				private object <rarityFX>5__5;

				private float <t>5__6;

				private float <unwrapTime>5__7;

				private FieldInfo <spinFXField>5__8;

				object IEnumerator<object>.Current
				{
					[DebuggerHidden]
					get
					{
						return <>2__current;
					}
				}

				object IEnumerator.Current
				{
					[DebuggerHidden]
					get
					{
						return <>2__current;
					}
				}

				[DebuggerHidden]
				public <FastOpenSequence>d__1(int <>1__state)
				{
					this.<>1__state = <>1__state;
				}

				[DebuggerHidden]
				void IDisposable.Dispose()
				{
					<isOpeningField>5__3 = null;
					<rarityFXProperty>5__4 = null;
					<rarityFX>5__5 = null;
					<spinFXField>5__8 = null;
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					//IL_008e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0098: Expected O, but got Unknown
					//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
					//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
					//IL_0155: Unknown result type (might be due to invalid IL or missing references)
					//IL_015f: Expected O, but got Unknown
					//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
					//IL_020c: Unknown result type (might be due to invalid IL or missing references)
					//IL_034a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0354: Unknown result type (might be due to invalid IL or missing references)
					//IL_028b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0295: Expected O, but got Unknown
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<speedMultiplier>5__2 = 0.01f;
						<isOpeningField>5__3 = AccessTools.Field(typeof(UIPlayerScroll), "IsOpening");
						<rarityFXProperty>5__4 = AccessTools.Property(typeof(UIPlayerScroll), "RarityFX");
						<isOpeningField>5__3.SetValue(__instance, true);
						<>2__current = (object)new WaitForSeconds(delay * <speedMultiplier>5__2);
						<>1__state = 1;
						return true;
					case 1:
					{
						<>1__state = -1;
						List<AudioClip> list = (List<AudioClip>)AccessTools.Field(typeof(UIPlayerScroll), "SpawnSFX").GetValue(__instance);
						if (list != null && list.Count > 0)
						{
							int index = Random.Range(0, list.Count);
							AudioClip val2 = list[index];
							if ((Object)(object)val2 != (Object)null)
							{
								AudioManager.PlayInterfaceSFX(val2, 1f, Random.Range(0.93f, 1.07f));
							}
						}
						__instance.ScrollAnim.CrossFade("Scroll_Horizontal", 0.05f);
						__instance.RevealFX.Play();
						<>2__current = (object)new WaitForSeconds((0.8f + delay * 2.1666665f) * <speedMultiplier>5__2);
						<>1__state = 2;
						return true;
					}
					case 2:
						<>1__state = -1;
						__instance.SealBurstFX.Play();
						<rarityFX>5__5 = <rarityFXProperty>5__4.GetValue(__instance);
						if (<rarityFX>5__5 != null)
						{
							FieldInfo fieldInfo = AccessTools.Field(<rarityFX>5__5.GetType(), "OpenFX");
							FieldInfo fieldInfo2 = AccessTools.Field(<rarityFX>5__5.GetType(), "OpenSFX");
							<spinFXField>5__8 = AccessTools.Field(<rarityFX>5__5.GetType(), "SpinFX");
							ParticleSystem val3 = (ParticleSystem)fieldInfo.GetValue(<rarityFX>5__5);
							List<AudioClip> list2 = (List<AudioClip>)fieldInfo2.GetValue(<rarityFX>5__5);
							if ((int)val3 != 0)
							{
								val3.Play();
							}
							if (list2 != null && list2.Count > 0)
							{
								int index2 = Random.Range(0, list2.Count);
								AudioClip val4 = list2[index2];
								if ((Object)(object)val4 != (Object)null)
								{
									AudioManager.PlayInterfaceSFX(val4, 1f, Random.Range(0.93f, 1.07f));
								}
							}
							__instance.ScrollAnim.CrossFade("Open", 0.1f);
							<>2__current = (object)new WaitForSeconds(0.594f * <speedMultiplier>5__2);
							<>1__state = 3;
							return true;
						}
						goto IL_02cd;
					case 3:
					{
						<>1__state = -1;
						ParticleSystem val = (ParticleSystem)<spinFXField>5__8.GetValue(<rarityFX>5__5);
						if ((int)val != 0)
						{
							val.Play();
						}
						<spinFXField>5__8 = null;
						goto IL_02cd;
					}
					case 4:
						{
							<>1__state = -1;
							break;
						}
						IL_02cd:
						<t>5__6 = 0f;
						<unwrapTime>5__7 = __instance.UnwrapTime * <speedMultiplier>5__2;
						break;
					}
					if (<t>5__6 < 1f)
					{
						<t>5__6 += Time.deltaTime / <unwrapTime>5__7;
						float num = __instance.UnwrapCurve.Evaluate(<t>5__6) * __instance.UnwrapWidth;
						__instance.maskRect.sizeDelta = new Vector2(num, __instance.maskRect.sizeDelta.y);
						<>2__current = null;
						<>1__state = 4;
						return true;
					}
					<isOpeningField>5__3.SetValue(__instance, 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();
				}
			}

			private static bool Prefix(UIPlayerScroll __instance, float delay, ref IEnumerator __result)
			{
				__result = FastOpenSequence(__instance, delay);
				return false;
			}

			[IteratorStateMachine(typeof(<FastOpenSequence>d__1))]
			private static IEnumerator FastOpenSequence(UIPlayerScroll __instance, float delay)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <FastOpenSequence>d__1(0)
				{
					__instance = __instance,
					delay = delay
				};
			}
		}

		[HarmonyPatch(typeof(UIPlayerScroll), "ChosenSequence")]
		public class UIPlayerScrollChosenPatch
		{
			[CompilerGenerated]
			private sealed class <FastChosenSequence>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

				public UIPlayerScroll __instance;

				private float <t>5__2;

				object IEnumerator<object>.Current
				{
					[DebuggerHidden]
					get
					{
						return <>2__current;
					}
				}

				object IEnumerator.Current
				{
					[DebuggerHidden]
					get
					{
						return <>2__current;
					}
				}

				[DebuggerHidden]
				public <FastChosenSequence>d__1(int <>1__state)
				{
					this.<>1__state = <>1__state;
				}

				[DebuggerHidden]
				void IDisposable.Dispose()
				{
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
					//IL_00cf: Expected O, but got Unknown
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						__instance.SplashVFX.Play();
						__instance.FlashGroup.alpha = 1f;
						<t>5__2 = 1f;
						goto IL_009d;
					case 1:
						<>1__state = -1;
						goto IL_009d;
					case 2:
						<>1__state = -1;
						<t>5__2 = 1f;
						break;
					case 3:
						{
							<>1__state = -1;
							break;
						}
						IL_009d:
						if (<t>5__2 > 0f)
						{
							<t>5__2 -= Time.deltaTime * 40f;
							__instance.FlashGroup.alpha = <t>5__2;
							<>2__current = null;
							<>1__state = 1;
							return true;
						}
						__instance.FlashGroup.alpha = 0f;
						<>2__current = (object)new WaitForSeconds(0.05f);
						<>1__state = 2;
						return true;
					}
					if (<t>5__2 > 0f)
					{
						<t>5__2 -= Time.deltaTime * 30f;
						__instance.UIGroup.alpha = <t>5__2;
						__instance.UIGroup.interactable = false;
						__instance.UIGroup.blocksRaycasts = false;
						<>2__current = null;
						<>1__state = 3;
						return true;
					}
					__instance.UIGroup.alpha = 0f;
					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();
				}
			}

			private static bool Prefix(UIPlayerScroll __instance, ref IEnumerator __result)
			{
				__result = FastChosenSequence(__instance);
				return false;
			}

			[IteratorStateMachine(typeof(<FastChosenSequence>d__1))]
			private static IEnumerator FastChosenSequence(UIPlayerScroll __instance)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <FastChosenSequence>d__1(0)
				{
					__instance = __instance
				};
			}
		}

		[HarmonyPatch(typeof(UIPlayerScroll), "ReleaseSequence")]
		public class UIPlayerScrollReleasePatch
		{
			[CompilerGenerated]
			private sealed class <FastReleaseSequence>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

				public UIPlayerScroll __instance;

				private float <t>5__2;

				object IEnumerator<object>.Current
				{
					[DebuggerHidden]
					get
					{
						return <>2__current;
					}
				}

				object IEnumerator.Current
				{
					[DebuggerHidden]
					get
					{
						return <>2__current;
					}
				}

				[DebuggerHidden]
				public <FastReleaseSequence>d__1(int <>1__state)
				{
					this.<>1__state = <>1__state;
				}

				[DebuggerHidden]
				void IDisposable.Dispose()
				{
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<t>5__2 = 1f;
						break;
					case 1:
						<>1__state = -1;
						break;
					}
					if (<t>5__2 > 0f)
					{
						<t>5__2 -= Time.deltaTime * 20f;
						__instance.UIGroup.alpha = <t>5__2;
						__instance.UIGroup.interactable = false;
						__instance.UIGroup.blocksRaycasts = false;
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					__instance.UIGroup.alpha = 0f;
					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();
				}
			}

			private static bool Prefix(UIPlayerScroll __instance, ref IEnumerator __result)
			{
				__result = FastReleaseSequence(__instance);
				return false;
			}

			[IteratorStateMachine(typeof(<FastReleaseSequence>d__1))]
			private static IEnumerator FastReleaseSequence(UIPlayerScroll __instance)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <FastReleaseSequence>d__1(0)
				{
					__instance = __instance
				};
			}
		}

		[HarmonyPatch(typeof(UIPlayerScroll), "EntryAnim")]
		public class UIPlayerScrollEntryPatch
		{
			private static void Postfix(UIPlayerScroll __instance)
			{
				__instance.ScrollAnim.speed = 10f;
			}
		}

		[HarmonyPatch(typeof(UIPlayerScroll), "Awake")]
		public class UIPlayerScrollAwakePatch
		{
			private static void Postfix(UIPlayerScroll __instance)
			{
				__instance.ScrollAnim.speed = 10f;
				((MonoBehaviour)__instance).Invoke("EntryAnim", Random.Range(0f, 0.05f));
			}
		}

		public override void OnInitializeMelon()
		{
			((MelonBase)this).LoggerInstance.Msg("Scroll Animation Speedup Mod loaded!");
		}
	}
}