using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using Configgy;
using HarmonyLib;
using Microsoft.CodeAnalysis;
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: AssemblyCompany("v1yapper")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+ba864e6b88ebbf6f61405c5716c96da76be64dac")]
[assembly: AssemblyProduct("v1yapper")]
[assembly: AssemblyTitle("v1yapper")]
[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 v1yapper
{
[BepInPlugin("arandomdumbass.ultrakill.v1yapper", "V1 Yapper", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
[HarmonyPatch(typeof(MenuEsc))]
[HarmonyPatch("OnDisable")]
public class Patch_Tutorial
{
[CompilerGenerated]
private sealed class <V1ResponseRoutine>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 <V1ResponseRoutine>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Expected O, but got Unknown
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
Subtitle("VOCAL INTERFACE CONNECTED. ESTABLISHING CONNECTION WITH THINKING PROCESS");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("tutorial.wav");
audio.Play();
<>2__current = (object)new WaitForSeconds(6.5f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("Well");
<>2__current = (object)new WaitForSeconds(0.9f);
<>1__state = 2;
return true;
case 2:
<>1__state = -1;
Subtitle("Here I am");
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 void Postfix(MenuEsc __instance)
{
if (!(SceneHelper.CurrentScene != "Tutorial"))
{
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
}
}
[IteratorStateMachine(typeof(<V1ResponseRoutine>d__1))]
private static IEnumerator V1ResponseRoutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutine>d__1(0);
}
}
[HarmonyPatch(typeof(ObjectActivator))]
[HarmonyPatch("OnEnable")]
public class Patch_idkwhatcausesthecerbcutscene
{
[CompilerGenerated]
private sealed class <V1ResponseRoutine>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 <V1ResponseRoutine>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Expected O, but got Unknown
//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
//IL_00c6: Expected O, but got Unknown
//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
//IL_00f1: Expected O, but got Unknown
//IL_0142: Unknown result type (might be due to invalid IL or missing references)
//IL_014c: Expected O, but got Unknown
//IL_016d: Unknown result type (might be due to invalid IL or missing references)
//IL_0177: Expected O, but got Unknown
//IL_0198: Unknown result type (might be due to invalid IL or missing references)
//IL_01a2: Expected O, but got Unknown
//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
//IL_01cd: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(0.2f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("Huh, theres text on this door");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("cerberus1.wav");
audio.Play();
<>2__current = (object)new WaitForSeconds(1.78f);
<>1__state = 2;
return true;
case 2:
<>1__state = -1;
Subtitle("Let me scan it for a second...");
<>2__current = (object)new WaitForSeconds(2.25f);
<>1__state = 3;
return true;
case 3:
<>1__state = -1;
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("cerberus2.wav");
audio.Play();
Subtitle("Damn");
<>2__current = (object)new WaitForSeconds(0.5f);
<>1__state = 4;
return true;
case 4:
<>1__state = -1;
Subtitle("This door's message is irrelevant");
<>2__current = (object)new WaitForSeconds(2f);
<>1__state = 5;
return true;
case 5:
<>1__state = -1;
Subtitle("Is there a way to get this thing open-");
<>2__current = (object)new WaitForSeconds(1.95f);
<>1__state = 6;
return true;
case 6:
<>1__state = -1;
Subtitle("Wait who the-");
<>2__current = (object)new WaitForSeconds(0.45f);
<>1__state = 7;
return true;
case 7:
<>1__state = -1;
Subtitle("God damn it, I have to fight for my life again");
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 void Postfix(ObjectActivator __instance)
{
if (SceneHelper.CurrentScene == "Level 0-5" && __instance.delay == 0f && !(((Object)((Component)__instance).gameObject).name != "Cube") && Object.op_Implicit((Object)(object)((Component)__instance).gameObject.GetComponent("ActivateArena")))
{
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
}
}
[IteratorStateMachine(typeof(<V1ResponseRoutine>d__1))]
private static IEnumerator V1ResponseRoutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutine>d__1(0);
}
}
[HarmonyPatch(typeof(ObjectActivator))]
[HarmonyPatch("Activate", new Type[] { typeof(bool) })]
public class Patch_Activations
{
[CompilerGenerated]
private sealed class <V1ResponseRoutineEartmover>d__2 : 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 <V1ResponseRoutineEartmover>d__2(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(1.25f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("It was about time you showed up");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("earthmoverintro.wav");
audio.Play();
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 <V1ResponseRoutineGun>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 <V1ResponseRoutineGun>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(1f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("Gosh, it's filthy in here");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("preludeintro.wav");
audio.Play();
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 void Postfix(ObjectActivator __instance)
{
if (((Object)((Component)__instance).gameObject).name == "Centaur Full")
{
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutineEartmover());
}
if (((Object)((Component)__instance).gameObject).name == "RevolverPickUp")
{
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutineGun());
}
}
[IteratorStateMachine(typeof(<V1ResponseRoutineGun>d__1))]
private static IEnumerator V1ResponseRoutineGun()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutineGun>d__1(0);
}
[IteratorStateMachine(typeof(<V1ResponseRoutineEartmover>d__2))]
private static IEnumerator V1ResponseRoutineEartmover()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutineEartmover>d__2(0);
}
}
[HarmonyPatch(typeof(V2))]
[HarmonyPatch("Start")]
public class Patch_V2
{
[CompilerGenerated]
private sealed class <V1ResponseRoutine>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 <V1ResponseRoutine>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Expected O, but got Unknown
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Expected O, but got Unknown
//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
//IL_00df: Expected O, but got Unknown
//IL_0109: Unknown result type (might be due to invalid IL or missing references)
//IL_0113: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(0.2f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("Oh who do you think you are?");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("v2intro.wav");
audio.Play();
<>2__current = (object)new WaitForSeconds(1.78f);
<>1__state = 2;
return true;
case 2:
<>1__state = -1;
if (ishouldreallystopmakingthese)
{
Subtitle("A machine with a near identical design to me?");
}
<>2__current = (object)new WaitForSeconds(2.6f);
<>1__state = 3;
return true;
case 3:
<>1__state = -1;
if (ishouldreallystopmakingthese)
{
Subtitle("Well I wont tolerate that at all");
}
<>2__current = (object)new WaitForSeconds(1.7f);
<>1__state = 4;
return true;
case 4:
<>1__state = -1;
if (ishouldreallystopmakingthese)
{
Subtitle("Time to settle this you dirty bootleg!");
}
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 void Postfix(V2 __instance)
{
if (__instance.inIntro)
{
ishouldreallystopmakingthese = true;
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
}
}
[IteratorStateMachine(typeof(<V1ResponseRoutine>d__1))]
private static IEnumerator V1ResponseRoutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutine>d__1(0);
}
}
[HarmonyPatch(typeof(V2))]
[HarmonyPatch("KnockedOut")]
public class Patch_V2CoinCheeze
{
[CompilerGenerated]
private sealed class <V1ResponseRoutine>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 <V1ResponseRoutine>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
ishouldreallystopmakingthese = false;
Subtitle("Your good at setting the tone");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("fuckyoulol.wav");
audio.Play();
<>2__current = (object)new WaitForSeconds(1.3f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("for someone in coin punching distance");
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 void Prefix(V2 __instance)
{
if (__instance.inIntro)
{
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
}
}
[IteratorStateMachine(typeof(<V1ResponseRoutine>d__1))]
private static IEnumerator V1ResponseRoutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutine>d__1(0);
}
}
[HarmonyPatch(typeof(WeaponPickUp))]
[HarmonyPatch("GotActivated")]
public class Patch_WeaponPickups
{
[CompilerGenerated]
private sealed class <V1ResponseRoutineKnuckleblaster>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 <V1ResponseRoutineKnuckleblaster>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
Subtitle("Not sure if they knew they dropped this when escaping");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("v2armtake.wav");
audio.Play();
<>2__current = (object)new WaitForSeconds(3.55f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("Oh well, its cool");
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 <V1ResponseRoutineNailgun>d__3 : 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 <V1ResponseRoutineNailgun>d__3(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
Subtitle("Another toy to kill people with");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("nailgunpickup.wav");
audio.Play();
<>2__current = (object)new WaitForSeconds(2.4f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("Wow!");
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 <V1ResponseRoutineRocketLauncher>d__4 : 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 <V1ResponseRoutineRocketLauncher>d__4(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
Subtitle("Haven't seen these things since my first test");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("rocketpickup.wav");
audio.Play();
<>2__current = (object)new WaitForSeconds(2.5f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("Nice to have them back on my hands");
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 <V1ResponseRoutineWhiplash>d__2 : 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 <V1ResponseRoutineWhiplash>d__2(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
Subtitle("Such good potential put to waste");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("v2armtake2.wav");
audio.Play();
<>2__current = (object)new WaitForSeconds(2.1f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("and I know I wont put it to waste");
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 void Postfix(WeaponPickUp __instance)
{
if (((Object)__instance).name == "RedArmPickup" && SceneHelper.CurrentScene == "Level 1-4")
{
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutineKnuckleblaster());
}
if (((Object)__instance).name == "RedArmPickup" && SceneHelper.CurrentScene == "Level 4-4")
{
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutineWhiplash());
}
if (((Object)__instance).name == "ShotgunPickUp")
{
Subtitle("Ooh a new weapon!");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("shotgunpickup.wav");
audio.Play();
}
if (((Object)__instance).name == "Weapon Pickup")
{
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutineNailgun());
}
if (((Object)__instance).name == "Railcannon (1)")
{
Subtitle("Oh yeah thats the ticket!");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("railcannonpickup.wav");
audio.Play();
}
if (((Object)__instance).name == "WeaponPickUp")
{
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutineRocketLauncher());
}
}
[IteratorStateMachine(typeof(<V1ResponseRoutineKnuckleblaster>d__1))]
private static IEnumerator V1ResponseRoutineKnuckleblaster()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutineKnuckleblaster>d__1(0);
}
[IteratorStateMachine(typeof(<V1ResponseRoutineWhiplash>d__2))]
private static IEnumerator V1ResponseRoutineWhiplash()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutineWhiplash>d__2(0);
}
[IteratorStateMachine(typeof(<V1ResponseRoutineNailgun>d__3))]
private static IEnumerator V1ResponseRoutineNailgun()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutineNailgun>d__3(0);
}
[IteratorStateMachine(typeof(<V1ResponseRoutineRocketLauncher>d__4))]
private static IEnumerator V1ResponseRoutineRocketLauncher()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutineRocketLauncher>d__4(0);
}
}
[HarmonyPatch(typeof(SlowMo))]
[HarmonyPatch("OnEnable")]
public class Patch_ReconstructWHAT
{
[CompilerGenerated]
private sealed class <V1ResponseRoutine>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 <V1ResponseRoutine>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(1f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("Goodnight you sweet and ugly prince");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("v2die.wav");
audio.Play();
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 void Postfix(SlowMo __instance)
{
if (((Object)__instance).name == "ToActivate" && SceneHelper.CurrentScene == "Level 4-4")
{
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
}
}
[IteratorStateMachine(typeof(<V1ResponseRoutine>d__1))]
private static IEnumerator V1ResponseRoutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutine>d__1(0);
}
}
[HarmonyPatch(typeof(Animator))]
[HarmonyPatch("Play", new Type[]
{
typeof(string),
typeof(int),
typeof(float)
})]
public class Patch_V22
{
[CompilerGenerated]
private sealed class <V1ResponseRoutine>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 <V1ResponseRoutine>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Expected O, but got Unknown
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_00ba: Expected O, but got Unknown
//IL_00db: Unknown result type (might be due to invalid IL or missing references)
//IL_00e5: Expected O, but got Unknown
//IL_0106: Unknown result type (might be due to invalid IL or missing references)
//IL_0110: Expected O, but got Unknown
//IL_0131: Unknown result type (might be due to invalid IL or missing references)
//IL_013b: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
specificvariablesothatv1doesnotrepeathimself = true;
<>2__current = (object)new WaitForSeconds(0.5f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("You again?");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("v2intro2.wav");
audio.Play();
<>2__current = (object)new WaitForSeconds(0.97f);
<>1__state = 2;
return true;
case 2:
<>1__state = -1;
Subtitle("What?");
<>2__current = (object)new WaitForSeconds(0.5f);
<>1__state = 3;
return true;
case 3:
<>1__state = -1;
Subtitle("You want to get your little arm that I rightfully earned and stole from you?");
<>2__current = (object)new WaitForSeconds(5.35f);
<>1__state = 4;
return true;
case 4:
<>1__state = -1;
Subtitle("Well...");
<>2__current = (object)new WaitForSeconds(0.95f);
<>1__state = 5;
return true;
case 5:
<>1__state = -1;
Subtitle("Come and get it!");
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 void Postfix(Animator __instance)
{
if (!(((Object)((Component)__instance).gameObject).name != "v2_GreenArm") && !specificvariablesothatv1doesnotrepeathimself)
{
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
}
}
[IteratorStateMachine(typeof(<V1ResponseRoutine>d__1))]
private static IEnumerator V1ResponseRoutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutine>d__1(0);
}
}
[HarmonyPatch(typeof(V2))]
[HarmonyPatch("InstaEnrage")]
public class Patch_FuckYouV2
{
[CompilerGenerated]
private sealed class <V1ResponseRoutine>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 <V1ResponseRoutine>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Expected O, but got Unknown
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(0.5f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
audio.Stop();
Subtitle("Why'd you do that?");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("v2enrage.wav");
audio.Play();
<>2__current = (object)new WaitForSeconds(1f);
<>1__state = 2;
return true;
case 2:
<>1__state = -1;
Subtitle("Hahahaha");
whyareyourepeatingenragevoicelinestopthat = 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 void Postfix(V2 __instance)
{
if (!audio.isPlaying && !whyareyourepeatingenragevoicelinestopthat)
{
whyareyourepeatingenragevoicelinestopthat = true;
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
}
}
[IteratorStateMachine(typeof(<V1ResponseRoutine>d__1))]
private static IEnumerator V1ResponseRoutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutine>d__1(0);
}
}
[HarmonyPatch(typeof(HudMessage))]
[HarmonyPatch("PlayMessage")]
public class Patch_maxor
{
private static void Postfix(ref string ___message)
{
if (___message == "You're not getting away this time.")
{
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("yournotgettingawaythistime.wav");
audio.Play();
}
}
}
[HarmonyPatch(typeof(SubtitledAudioSource))]
[HarmonyPatch("OnEnable")]
public class Patch_Gab1Intro1
{
[CompilerGenerated]
private sealed class <V1ResponseRoutine2>d__2 : 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 <V1ResponseRoutine2>d__2(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Expected O, but got Unknown
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Expected O, but got Unknown
//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
//IL_00d6: Expected O, but got Unknown
//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
//IL_0101: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(2.5f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("I think I've heard of you");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("gabriel2.wav");
audio.Play();
<>2__current = (object)new WaitForSeconds(1.9f);
<>1__state = 2;
return true;
case 2:
<>1__state = -1;
Subtitle("Perhaps Archangel Gabriel?");
<>2__current = (object)new WaitForSeconds(2.35f);
<>1__state = 3;
return true;
case 3:
<>1__state = -1;
Subtitle("No matter the less, you know whats coming");
<>2__current = (object)new WaitForSeconds(2.9f);
<>1__state = 4;
return true;
case 4:
<>1__state = -1;
Subtitle("and you will exchange with me");
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 <V1ResponseRoutine3>d__3 : 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 <V1ResponseRoutine3>d__3(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(2f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("And shall the angel's blood run red");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("gabriel3.wav");
audio.Play();
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 <V1ResponseRoutine4>d__4 : 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 <V1ResponseRoutine4>d__4(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(1f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("Good morning, angel");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("gabriel21.wav");
audio.Play();
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 <V1ResponseRoutine>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 <V1ResponseRoutine>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(4.5f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("Can't comply with that request as of now");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("gabriel1.wav");
audio.Play();
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 void Postfix(SubtitledAudioSource __instance)
{
if (((Object)((Component)__instance).gameObject).name == "gab_Intro1")
{
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
}
if (((Object)((Component)__instance).gameObject).name == "gab_Intro2")
{
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine2());
}
if (((Object)((Component)__instance).gameObject).name == "gab_Intro3")
{
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine3());
}
if (((Object)((Component)__instance).gameObject).name == "Speech" && !specificvariablesothatv1doesnotrepeathimself)
{
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine4());
}
}
[IteratorStateMachine(typeof(<V1ResponseRoutine>d__1))]
private static IEnumerator V1ResponseRoutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutine>d__1(0);
}
[IteratorStateMachine(typeof(<V1ResponseRoutine2>d__2))]
private static IEnumerator V1ResponseRoutine2()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutine2>d__2(0);
}
[IteratorStateMachine(typeof(<V1ResponseRoutine3>d__3))]
private static IEnumerator V1ResponseRoutine3()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutine3>d__3(0);
}
[IteratorStateMachine(typeof(<V1ResponseRoutine4>d__4))]
private static IEnumerator V1ResponseRoutine4()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutine4>d__4(0);
}
}
[HarmonyPatch(typeof(GabrielOutro))]
[HarmonyPatch("Disappear")]
public class Patch_Gab1Outro
{
[CompilerGenerated]
private sealed class <V1ResponseRoutine>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 <V1ResponseRoutine>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Expected O, but got Unknown
//IL_011f: Unknown result type (might be due to invalid IL or missing references)
//IL_0129: Expected O, but got Unknown
//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
//IL_00fe: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(2f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
audio.Stop();
if (SceneHelper.CurrentScene == "Level 3-2")
{
Subtitle("I think that \"Gabriel\" guy has problems");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("gabriel4.wav");
audio.Play();
}
if (SceneHelper.CurrentScene == "Level 6-2")
{
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("gabriel23.wav");
audio.Play();
Subtitle("Okay");
<>2__current = (object)new WaitForSeconds(0.6f);
<>1__state = 2;
return true;
}
break;
case 2:
<>1__state = -1;
Subtitle("STATUS UPDATE:");
<>2__current = (object)new WaitForSeconds(1.35f);
<>1__state = 3;
return true;
case 3:
<>1__state = -1;
Subtitle("Mr \"Archangel Gabriel\" is not okay in the head");
break;
}
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 void Postfix(GabrielIntro __instance)
{
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
}
[IteratorStateMachine(typeof(<V1ResponseRoutine>d__1))]
private static IEnumerator V1ResponseRoutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutine>d__1(0);
}
}
[HarmonyPatch(typeof(GabrielBase))]
[HarmonyPatch("EnrageNow")]
public class Patch_GabEnrage
{
[CompilerGenerated]
private sealed class <V1ResponseRoutine2>d__2 : 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 <V1ResponseRoutine2>d__2(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(0.25f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("I'd like to see you try");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("gabriel22.wav");
audio.Play();
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 <V1ResponseRoutine>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 <V1ResponseRoutine>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(0.7f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("Oh. Is baby archangel Gabriel getting a bit cranky now?");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("gabrieltaunt.wav");
audio.Play();
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 void Postfix(GabrielBase __instance)
{
if (SceneHelper.CurrentScene == "Level 3-2")
{
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
}
if (SceneHelper.CurrentScene == "Level 6-2")
{
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine2());
}
}
[IteratorStateMachine(typeof(<V1ResponseRoutine>d__1))]
private static IEnumerator V1ResponseRoutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutine>d__1(0);
}
[IteratorStateMachine(typeof(<V1ResponseRoutine2>d__2))]
private static IEnumerator V1ResponseRoutine2()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutine2>d__2(0);
}
}
[HarmonyPatch(typeof(GabrielBase))]
[HarmonyPatch("UnEnrage")]
public class Patch_GabUnenrage
{
[CompilerGenerated]
private sealed class <V1ResponseRoutine>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 <V1ResponseRoutine>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(0.7f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("What the hell are you doing?");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("gabriel2taunt.wav");
audio.Play();
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 void Postfix(GabrielBase __instance)
{
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
}
[IteratorStateMachine(typeof(<V1ResponseRoutine>d__1))]
private static IEnumerator V1ResponseRoutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutine>d__1(0);
}
}
[HarmonyPatch(typeof(AddStylePoints))]
[HarmonyPatch("Activate")]
public class Patch_EarthmoverOutro
{
[CompilerGenerated]
private sealed class <V1ResponseRoutine>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 <V1ResponseRoutine>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(1f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("Au revoir, vieil ami");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("earthmoveroutro.wav");
audio.Play();
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 void Postfix(AddStylePoints __instance)
{
if (!(__instance.styleName != "RAISON D'ETRE"))
{
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
}
}
[IteratorStateMachine(typeof(<V1ResponseRoutine>d__1))]
private static IEnumerator V1ResponseRoutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutine>d__1(0);
}
}
[HarmonyPatch(typeof(FleshPrison))]
[HarmonyPatch("Start")]
public class Patch_FleshIntro
{
private static void Postfix(FleshPrison __instance)
{
audio.Stop();
if (!__instance.altVersion)
{
Subtitle("WHAT IN THE ACTUAL FUCK IS THAT THING?!");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("flesh1.wav");
}
else
{
Subtitle("OH GOOD LORD");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("flesh2.wav");
}
audio.Play();
}
}
[HarmonyPatch(typeof(MinosPrime))]
[HarmonyPatch("Start")]
public class Patch_MPIntro
{
[CompilerGenerated]
private sealed class <V1ResponseRoutine>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 <V1ResponseRoutine>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(0.25f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("And yet it will be your punishment aswell");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("minosintro.wav");
audio.Play();
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 void Postfix(MinosPrime __instance)
{
Traverse val = Traverse.Create((object)__instance);
if (!val.Field("bossVersion").GetValue().Equals(false))
{
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
}
}
[IteratorStateMachine(typeof(<V1ResponseRoutine>d__1))]
private static IEnumerator V1ResponseRoutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutine>d__1(0);
}
}
[HarmonyPatch(typeof(MinosPrime))]
[HarmonyPatch("OutroEnd")]
public class Patch_MPOutro
{
[CompilerGenerated]
private sealed class <V1ResponseRoutine>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 <V1ResponseRoutine>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Expected O, but got Unknown
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(0.5f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("Goodnight, Minos");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("minosoutro.wav");
audio.Play();
<>2__current = (object)new WaitForSeconds(1.75f);
<>1__state = 2;
return true;
case 2:
<>1__state = -1;
Subtitle("You put up a good fight for someone who died as the king of lust");
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 void Postfix(MinosPrime __instance)
{
Traverse val = Traverse.Create((object)__instance);
if (!val.Field("bossVersion").GetValue().Equals(false))
{
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
}
}
[IteratorStateMachine(typeof(<V1ResponseRoutine>d__1))]
private static IEnumerator V1ResponseRoutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutine>d__1(0);
}
}
[HarmonyPatch(typeof(SisyphusPrime))]
[HarmonyPatch("Start")]
public class Patch_SPIntro
{
[CompilerGenerated]
private sealed class <V1ResponseRoutine>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 <V1ResponseRoutine>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(0.25f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("OH GOD OH FUCK WAIT NONONONONO, I DONT WANT TO FIGHT YOU I JUST WANTED SOME BLOOD PLEASE GOD NO");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("sisyintro.wav");
audio.Play();
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 void Postfix(SisyphusPrime __instance)
{
Traverse val = Traverse.Create((object)__instance);
if (!val.Field("bossVersion").GetValue().Equals(false))
{
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
}
}
[IteratorStateMachine(typeof(<V1ResponseRoutine>d__1))]
private static IEnumerator V1ResponseRoutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutine>d__1(0);
}
}
[HarmonyPatch(typeof(SisyphusPrime))]
[HarmonyPatch("OutroEnd")]
public class Patch_SPOutro
{
[CompilerGenerated]
private sealed class <V1ResponseRoutine>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 <V1ResponseRoutine>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Expected O, but got Unknown
//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
//IL_00b4: Expected O, but got Unknown
//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
//IL_00df: Expected O, but got Unknown
//IL_0100: Unknown result type (might be due to invalid IL or missing references)
//IL_010a: Expected O, but got Unknown
//IL_012b: Unknown result type (might be due to invalid IL or missing references)
//IL_0135: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(0.5f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("Honestly");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("sisyoutro.wav");
audio.Play();
<>2__current = (object)new WaitForSeconds(0.85f);
<>1__state = 2;
return true;
case 2:
<>1__state = -1;
Subtitle("That guy");
<>2__current = (object)new WaitForSeconds(0.75f);
<>1__state = 3;
return true;
case 3:
<>1__state = -1;
Subtitle("Sisyphus?");
<>2__current = (object)new WaitForSeconds(0.85f);
<>1__state = 4;
return true;
case 4:
<>1__state = -1;
Subtitle("I dont like him");
<>2__current = (object)new WaitForSeconds(1.5f);
<>1__state = 5;
return true;
case 5:
<>1__state = -1;
Subtitle("Fuck him");
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 void Postfix(SisyphusPrime __instance)
{
Traverse val = Traverse.Create((object)__instance);
if (!val.Field("bossVersion").GetValue().Equals(false))
{
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
}
}
[IteratorStateMachine(typeof(<V1ResponseRoutine>d__1))]
private static IEnumerator V1ResponseRoutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutine>d__1(0);
}
}
[HarmonyPatch(typeof(LevelNameActivator))]
[HarmonyPatch("Start")]
public class Patch_disintergrationloop
{
[CompilerGenerated]
private sealed class <V1ResponseRoutine>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 <V1ResponseRoutine>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(0.25f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("What the fuck?");
audio.Stop();
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("wtf.wav");
audio.Play();
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 void Postfix(LevelNameActivator __instance)
{
if (!(SceneHelper.CurrentScene != "Level 8-3"))
{
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
}
}
[IteratorStateMachine(typeof(<V1ResponseRoutine>d__1))]
private static IEnumerator V1ResponseRoutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutine>d__1(0);
}
}
[HarmonyPatch(typeof(HellMap))]
[HarmonyPatch("Start")]
public class Patch_LevelEnter
{
[CompilerGenerated]
private sealed class <V1ResponseRoutine>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 <V1ResponseRoutine>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
Subtitle("Must nothing stop me");
<>2__current = (object)new WaitForSeconds(1.6f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("I need to keep going");
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 void Postfix(HellMap __instance)
{
specificvariablesothatv1doesnotrepeathimself = false;
anotherspecificvarfor2ndgabfight = false;
Log.LogInfo((object)SceneHelper.CurrentScene);
if (SceneHelper.CurrentScene == "uk_construct" || SceneHelper.CurrentScene == "Level 0-S" || SceneHelper.CurrentScene == "Level 1-S" || SceneHelper.CurrentScene == "Level 4-S" || SceneHelper.CurrentScene == "Level 5-S" || SceneHelper.CurrentScene == "Level 7-S" || SceneHelper.CurrentScene == "Level 8-S")
{
Subtitle("Lets take a look");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("secretlevel.wav");
}
else if (SceneHelper.CurrentScene == "Endless")
{
int num = Random.Range(1, 5);
if (num == 1)
{
Subtitle("Oh boy");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("cybergrind1.wav");
}
if (num == 2)
{
Subtitle("Training time");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("cybergrind2.wav");
}
if (num == 3)
{
Subtitle("Can I reach a new high though?");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("cybergrind3.wav");
}
if (num == 4)
{
Subtitle("Sometimes I just need a break from all this");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("cybergrind4.wav");
}
}
else
{
int num2 = Random.Range(1, 11);
if (num2 == 1)
{
Subtitle("Still going...");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("descend1.wav");
}
if (num2 == 2)
{
Subtitle("There needs to be more for me");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("descend2.wav");
}
if (num2 == 3)
{
Subtitle("What do we have in store today?");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("descend3.wav");
}
if (num2 == 4)
{
Subtitle("I starve for more");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("descend4.wav");
}
if (num2 == 5)
{
Subtitle("Already?");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("descend5.wav");
}
if (num2 == 6)
{
Subtitle("Again?");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("descend6.wav");
}
if (num2 == 7)
{
Subtitle("No longer can I keep sleep");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("descend7.wav");
}
if (num2 == 8)
{
Subtitle("I just might get there");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("descend8.wav");
}
if (num2 == 9)
{
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("descend9.wav");
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
}
if (num2 == 10)
{
Subtitle("Sometimes I dream of eternal sleep");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("descend10.wav");
}
}
audio.Play();
}
[IteratorStateMachine(typeof(<V1ResponseRoutine>d__1))]
private static IEnumerator V1ResponseRoutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutine>d__1(0);
}
}
[HarmonyPatch(typeof(StyleHUD))]
[HarmonyPatch("AscendRank")]
public class Patch_ULTRAKILL
{
private static void Postfix(StyleHUD __instance)
{
if (__instance.rankIndex != 7 || audio.isPlaying)
{
return;
}
int num = Random.Range(1, 4);
if (num == 1)
{
if (((ConfigValueElement<bool>)(object)colortoggle).Value)
{
MonoSingleton<SubtitleController>.Instance.DisplaySubtitle("<color=#0464ff>I cannot be stopped. You will all be</color> <color=#ff0000>ULTRAKILLED</color>", (AudioSource)null, false);
}
else
{
MonoSingleton<SubtitleController>.Instance.DisplaySubtitle("I cannot be stopped. You will all be <color=#ff0000>ULTRAKILLED</color>", (AudioSource)null, false);
}
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("ultrakill1.wav");
}
if (num == 2)
{
if (((ConfigValueElement<bool>)(object)colortoggle).Value)
{
MonoSingleton<SubtitleController>.Instance.DisplaySubtitle("<color=#0464ff>You. Have. Been.</color> <color=#ff0000>ULTRAKILLED</color>", (AudioSource)null, false);
}
else
{
MonoSingleton<SubtitleController>.Instance.DisplaySubtitle("You. Have. Been. <color=#ff0000>ULTRAKILLED</color>", (AudioSource)null, false);
}
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("ultrakill2.wav");
}
if (num == 3)
{
if (((ConfigValueElement<bool>)(object)colortoggle).Value)
{
MonoSingleton<SubtitleController>.Instance.DisplaySubtitle("<color=#0464ff>Have you not learned a single thing? In this world it's </color><color=#ff0000>ULTRAKILL</color><color=#0464ff> or BE </color><color=#ff0000>ULTRAKILLED</color>", (AudioSource)null, false);
}
else
{
MonoSingleton<SubtitleController>.Instance.DisplaySubtitle("Have you not learned a single thing? In this world it's <color=#ff0000>ULTRAKILL</color> or BE <color=#ff0000>ULTRAKILLED</color>", (AudioSource)null, false);
}
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("ultrakill3.wav");
}
audio.Play();
}
}
[HarmonyPatch(typeof(NewMovement))]
[HarmonyPatch("TryDash")]
public class Patch_Dash
{
private static void Postfix(NewMovement __instance)
{
if (audio.isPlaying)
{
return;
}
int num = Random.Range(1, ((ConfigValueElement<int>)(object)dashlinechance).Value + 1);
if (num == 1)
{
int num2 = Random.Range(1, 4);
if (num2 == 1)
{
Subtitle("Vroom!");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("dash1.wav");
}
if (num2 == 2)
{
Subtitle("Yikes!");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("dash2.wav");
}
if (num2 == 3)
{
Subtitle("Whoosh");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("dash3.wav");
}
audio.Play();
}
}
}
[HarmonyPatch(typeof(NewMovement))]
[HarmonyPatch("TryStartSlam")]
public class Patch_Slam
{
private static void Postfix(NewMovement __instance)
{
if (audio.isPlaying)
{
return;
}
int num = Random.Range(1, ((ConfigValueElement<int>)(object)slamlinechance).Value + 1);
if (num == 1)
{
int num2 = Random.Range(1, 4);
if (num2 == 1)
{
Subtitle("Incoming");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("slam1.wav");
}
if (num2 == 2)
{
Subtitle("Here I come");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("slam2.wav");
}
if (num2 == 3)
{
Subtitle("Slam!");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("slam3.wav");
}
audio.Play();
}
}
}
[HarmonyPatch(typeof(PlayOnAwakeTracker))]
[HarmonyPatch("OnEnable")]
public class Patch_DashJump
{
private static void Postfix(PlayOnAwakeTracker __instance)
{
if (!((Object)((Component)__instance).gameObject).name.Contains("DashJumpSound") || audio.isPlaying)
{
return;
}
int num = Random.Range(1, ((ConfigValueElement<int>)(object)dashjumplinechance).Value + 1);
if (num == 1)
{
int num2 = Random.Range(1, 4);
if (num2 == 1)
{
Subtitle("Weeeeee!");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("ssj1.wav");
}
if (num2 == 2)
{
Subtitle("Covering long distance");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("ssj2.wav");
}
if (num2 == 3)
{
Subtitle("Gotta move");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("ssj3.wav");
}
audio.Play();
}
}
}
[HarmonyPatch(typeof(NewMovement))]
[HarmonyPatch("Parry")]
public class Patch_Parry
{
private static void Postfix(NewMovement __instance)
{
if (audio.isPlaying)
{
return;
}
int num = Random.Range(1, ((ConfigValueElement<int>)(object)parrylinechance).Value + 1);
if (num == 1)
{
int num2 = Random.Range(1, 6);
if (num2 == 1)
{
Subtitle("Nuh uh!");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("parry1.wav");
}
if (num2 == 2)
{
Subtitle("Parry!");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("parry2.wav");
}
if (num2 == 3)
{
Subtitle("Denied");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("parry3.wav");
}
if (num2 == 4)
{
Subtitle("Too bad");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("parry4.wav");
}
if (num2 == 5)
{
Subtitle("Back to you");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("parry5.wav");
}
audio.Play();
}
}
}
[HarmonyPatch(typeof(NewMovement))]
[HarmonyPatch("GetHurt")]
public class Patch_Hurt
{
private static void Postfix(NewMovement __instance)
{
if (__instance.dead)
{
audio.Stop();
return;
}
int num = Random.Range(1, ((ConfigValueElement<int>)(object)hurtlinechance).Value + 1);
if (num == 1 && !audio.isPlaying)
{
int num2 = Random.Range(1, 6);
if (num2 == 1)
{
Subtitle("Ow! You bitch!");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("hurt1.wav");
}
if (num2 == 2)
{
Subtitle("Stop trying");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("hurt2.wav");
}
if (num2 == 3)
{
Subtitle("My god, just die already");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("hurt3.wav");
}
if (num2 == 4)
{
Subtitle("Oh... That didn't feel very good");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("hurt4.wav");
}
if (num2 == 5)
{
Subtitle("No, no, Stop it");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("hurt5.wav");
}
audio.Play();
}
}
}
[HarmonyPatch(typeof(Punch))]
[HarmonyPatch("ForceHold")]
public class Patch_Pickup
{
private static void Postfix(Punch __instance)
{
if (audio.isPlaying)
{
return;
}
int num = Random.Range(1, ((ConfigValueElement<int>)(object)pickupchance).Value + 1);
if (num == 1)
{
int num2 = Random.Range(1, 4);
if (num2 == 1)
{
Subtitle("This'll do");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("pickup1.wav");
}
if (num2 == 2)
{
Subtitle("I'll be taking that");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("pickup2.wav");
}
if (num2 == 3)
{
Subtitle("This'll come in handy");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("pickup3.wav");
}
audio.Play();
}
}
}
[HarmonyPatch(typeof(Punch))]
[HarmonyPatch("CoinFlip")]
public class Patch_Coinflip
{
private static void Postfix(Punch __instance)
{
if (audio.isPlaying)
{
return;
}
int num = Random.Range(1, ((ConfigValueElement<int>)(object)coinchance).Value + 1);
if (num == 1)
{
int num2 = Random.Range(1, 6);
if (num2 == 1)
{
Subtitle("Here's some payment");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("coin1.wav");
}
if (num2 == 2)
{
Subtitle("Watch out");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("coin2.wav");
}
if (num2 == 3)
{
Subtitle("Take bit of this");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("coin3.wav");
}
if (num2 == 4)
{
Subtitle("Raining some money");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("coin4.wav");
}
if (num2 == 5)
{
Subtitle("You deserve some of this!");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("coin5.wav");
}
audio.Play();
}
}
}
[HarmonyPatch(typeof(Shotgun))]
[HarmonyPatch("ShootSaw", new Type[] { })]
public class Patch_Saw
{
private static void Postfix(Shotgun __instance)
{
if (audio.isPlaying)
{
return;
}
int num = Random.Range(1, ((ConfigValueElement<int>)(object)sawchance).Value + 1);
if (num == 1)
{
int num2 = Random.Range(1, 4);
if (num2 == 1)
{
Subtitle("I hope you went to the dentist");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("saw1.wav");
}
if (num2 == 2)
{
Subtitle("Just a bit of this too");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("saw2.wav");
}
if (num2 == 3)
{
Subtitle("Meet my pal");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("saw3.wav");
}
audio.Play();
}
}
}
[HarmonyPatch(typeof(Shotgun))]
[HarmonyPatch("Pump", new Type[] { })]
public class Patch_Pump
{
[CompilerGenerated]
private sealed class <V1ResponseRoutine2>d__2 : 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 <V1ResponseRoutine2>d__2(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
Subtitle("You aren't getting out of my target value");
<>2__current = (object)new WaitForSeconds(2f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("You fucking blood canister");
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 <V1ResponseRoutine>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 <V1ResponseRoutine>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
Subtitle("I will shit fury all over you");
<>2__current = (object)new WaitForSeconds(1.45f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("and you will drown in it");
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 void Postfix(Shotgun __instance)
{
if (audio.isPlaying)
{
return;
}
int num = Random.Range(1, ((ConfigValueElement<int>)(object)pumpchance).Value + 1);
if (num == 1)
{
int num2 = Random.Range(1, 6);
if (num2 == 1)
{
Subtitle("Oh i'm gonna fuck your face so hard your brains will shit itself all over the place");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("pump1.wav");
}
if (num2 == 2)
{
Subtitle("I'm gonna make you feel my wrath, fucker");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("pump2.wav");
}
if (num2 == 3)
{
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("pump3.wav");
Subtitle("I'm gonna send you back to being a unmoving bitch");
}
if (num2 == 4)
{
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("pump4.wav");
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
}
if (num2 == 5)
{
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("pump5.wav");
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine2());
}
audio.Play();
}
}
[IteratorStateMachine(typeof(<V1ResponseRoutine>d__1))]
private static IEnumerator V1ResponseRoutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutine>d__1(0);
}
[IteratorStateMachine(typeof(<V1ResponseRoutine2>d__2))]
private static IEnumerator V1ResponseRoutine2()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutine2>d__2(0);
}
}
[HarmonyPatch(typeof(ShotgunHammer))]
[HarmonyPatch("ShootSaw", new Type[] { })]
public class Patch_Saw2
{
private static void Postfix(Shotgun __instance)
{
if (audio.isPlaying)
{
return;
}
int num = Random.Range(1, ((ConfigValueElement<int>)(object)sawchance).Value + 1);
if (num == 1)
{
int num2 = Random.Range(1, 4);
if (num2 == 1)
{
Subtitle("I hope you went to the dentist");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("saw1.wav");
}
if (num2 == 2)
{
Subtitle("Just a bit of this too");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("saw2.wav");
}
if (num2 == 3)
{
Subtitle("Meet my pal");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("saw3.wav");
}
audio.Play();
}
}
}
[HarmonyPatch(typeof(ShotgunHammer))]
[HarmonyPatch("Pump", new Type[] { })]
public class Patch_Pump2
{
[CompilerGenerated]
private sealed class <V1ResponseRoutine2>d__2 : 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 <V1ResponseRoutine2>d__2(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
Subtitle("You aren't getting out of my target value");
<>2__current = (object)new WaitForSeconds(2f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("You fucking blood canister");
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 <V1ResponseRoutine>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 <V1ResponseRoutine>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
Subtitle("I will shit fury all over you");
<>2__current = (object)new WaitForSeconds(1.45f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Subtitle("and you will drown in it");
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 void Postfix(Shotgun __instance)
{
if (audio.isPlaying)
{
return;
}
int num = Random.Range(1, ((ConfigValueElement<int>)(object)pumpchance).Value + 1);
if (num == 1)
{
int num2 = Random.Range(1, 6);
if (num2 == 1)
{
Subtitle("Oh i'm gonna fuck your face so hard your brains will shit itself all over the place");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("pump1.wav");
}
if (num2 == 2)
{
Subtitle("I'm gonna make you feel my wrath, fucker");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("pump2.wav");
}
if (num2 == 3)
{
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("pump3.wav");
Subtitle("I'm gonna send you back to being a unmoving bitch");
}
if (num2 == 4)
{
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("pump4.wav");
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
}
if (num2 == 5)
{
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("pump5.wav");
((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine2());
}
audio.Play();
}
}
[IteratorStateMachine(typeof(<V1ResponseRoutine>d__1))]
private static IEnumerator V1ResponseRoutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutine>d__1(0);
}
[IteratorStateMachine(typeof(<V1ResponseRoutine2>d__2))]
private static IEnumerator V1ResponseRoutine2()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <V1ResponseRoutine2>d__2(0);
}
}
[HarmonyPatch(typeof(Railcannon))]
[HarmonyPatch("OnEnable", new Type[] { })]
public class Patch_Railcannon
{
private static void Postfix(Railcannon __instance)
{
if (audio.isPlaying)
{
return;
}
int num = Random.Range(1, ((ConfigValueElement<int>)(object)railchance).Value + 1);
if (num == 1)
{
int num2 = Random.Range(1, 5);
if (num2 == 1)
{
Subtitle("Stand still...");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("railcannon1.wav");
}
if (num2 == 2)
{
Subtitle("Suprise!");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("railcannon2.wav");
}
if (num2 == 3)
{
Subtitle("More firepower is required");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("railcannon3.wav");
}
if (num2 == 4)
{
Subtitle("You'll make a fine meal");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("railcannon4.wav");
}
audio.Play();
}
}
}
[HarmonyPatch(typeof(Punch))]
[HarmonyPatch("ParryProjectile")]
public class Patch_Boost
{
private static void Postfix(Projectile proj)
{
if (audio.isPlaying || !proj.boosted)
{
return;
}
int num = Random.Range(1, ((ConfigValueElement<int>)(object)pjboostchance).Value + 1);
if (num == 1)
{
int num2 = Random.Range(1, 4);
if (num2 == 1)
{
Subtitle("Bet you cant do this!");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("boost1.wav");
}
if (num2 == 2)
{
Subtitle("Extra flavor");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("boost2.wav");
}
if (num2 == 3)
{
Subtitle("Take this!");
audio.clip = V1AssetBundle.LoadAsset<AudioClip>("boost3.wav");
}
audio.Play();
}
}
}
internal static ManualLogSource Log;
public static bool specificvariablesothatv1doesnotrepeathimself = false;
public static bool anotherspecificvarfor2ndgabfight = false;
public static bool whyareyourepeatingenragevoicelinestopthat = false;
public static bool ishouldreallystopmakingthese = false;
public static Plugin me;
public static AudioSource audio;
public static string FolderPath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
private ConfigBuilder config;
[Configgable("Yapping", "Dash line chance", 0, "The higher the value, the more rare the line is.")]
public static IntegerSlider dashlinechance = new IntegerSlider(6, 0, 50);
[Configgable("Yapping", "Dash Jump line chance", 0, "The higher the value, the more rare the line is.")]
public static IntegerSlider dashjumplinechance = new IntegerSlider(2, 0, 50);
[Configgable("Yapping", "Slam line chance", 0, "The higher the value, the more rare the line is.")]
public static IntegerSlider slamlinechance = new IntegerSlider(6, 0, 50);
[Configgable("Yapping", "Parry line chance", 0, "The higher the value, the more rare the line is.")]
public static IntegerSlider parrylinechance = new IntegerSlider(1, 0, 50);
[Configgable("Yapping", "Hurt line chance", 0, "The higher the value, the more rare the line is.")]
public static IntegerSlider hurtlinechance = new IntegerSlider(2, 0, 50);
[Configgable("Yapping", "Pickup line chance", 0, "The higher the value, the more rare the line is.")]
public static IntegerSlider pickupchance = new IntegerSlider(2, 0, 50);
[Configgable("Yapping", "(Revolver) Coin line chance", 0, "The higher the value, the more rare the line is.")]
public static IntegerSlider coinchance = new IntegerSlider(2, 0, 50);
[Configgable("Yapping", "(Shotgun) Chainsaw line chance", 0, "The higher the value, the more rare the line is.")]
public static IntegerSlider sawchance = new IntegerSlider(2, 0, 50);
[Configgable("Yapping", "(Shotgun) Pump line chance", 0, "The higher the value, the more rare the line is.")]
public static IntegerSlider pumpchance = new IntegerSlider(3, 0, 50);
[Configgable("Yapping", "Railcannon line chance", 0, "The higher the value, the more rare the line is.")]
public static IntegerSlider railchance = new IntegerSlider(2, 0, 50);
[Configgable("Yapping", "Projectile Boost line chance", 0, "The higher the value, the more rare the line is.")]
public static IntegerSlider pjboostchance = new IntegerSlider(2, 0, 50);
[Configgable("Visual", "Colored Subtitles", 0, "Gives V1's subtitles some fancy colors :D")]
private static ConfigToggle colortoggle = new ConfigToggle(false);
[Configgable("Audio", "Voice Volume", 0, "self-explanatory")]
[Range(0f, 1f)]
private static float volslid = 1f;
public static AssetBundle V1AssetBundle { get; private set; }
private void Awake()
{
//IL_0036: 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_0056: Expected O, but got Unknown
me = this;
audio = ((Component)this).gameObject.AddComponent<AudioSource>();
V1AssetBundle = AssetBundle.LoadFromFile(Path.Combine(FolderPath, "v1yapper"));
new Harmony("arandomdumbass.ultrakill.v1yapper").PatchAll();
config = new ConfigBuilder("arandomdumbass.v1yapper", "V1 Yapper");
config.BuildAll();
Log = ((BaseUnityPlugin)this).Logger;
Log.LogInfo((object)"oh my god do you ever shut the fuck up john v1 ultrakill");
}
private void Update()
{
audio.volume = volslid;
}
public static void Subtitle(string text)
{
if (!string.IsNullOrEmpty(text))
{
if (((ConfigValueElement<bool>)(object)colortoggle).Value)
{
string text2 = "<color=#0464ff>" + text + "</color>";
MonoSingleton<SubtitleController>.Instance.DisplaySubtitle(text2, (AudioSource)null, false);
}
else
{
MonoSingleton<SubtitleController>.Instance.DisplaySubtitle(text, (AudioSource)null, false);
}
}
}
}
}
