using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("CGRetry")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+be27bc9df1cf25fb67601fa30b662497fc307cf3")]
[assembly: AssemblyProduct("CGRetry")]
[assembly: AssemblyTitle("CGRetry")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace CGR
{
[BepInPlugin("51.CGRetry", "CGRetry", "1.0.0")]
internal class Plugin : BaseUnityPlugin
{
private class ConfigManager
{
public static ConfigEntry<int> retryStartRank;
public static ConfigEntry<float> retryStartupTime;
public static void Initialize(ConfigFile file)
{
retryStartRank = file.Bind<int>("Options", "Retry Start Rank", 6, "The rank you get at the start of a retried wave\n0: Destructive\n1: Chaotic\n2: Brutal\n3: Anarchic\n4: Supreme\n5: SSadistic\n6: SSShitstorm\n7: ULTRAKILL");
retryStartupTime = file.Bind<float>("Options", "Retry Startup Time", 1f, "How long you wait before the retried wave reloads");
}
}
private class RNG
{
private static Random rng = new Random();
public static void SetSeed(int seed)
{
rng = new Random(seed);
}
public static int RangeInt(int min, int max)
{
return rng.Next(min, max);
}
public static float RangeFloat(float min, float max)
{
return (float)(rng.NextDouble() * (double)(max - min) + (double)min);
}
}
private class DialogManager
{
[Serializable]
[CompilerGenerated]
private sealed class <>c
{
public static readonly <>c <>9 = new <>c();
public static UnityAction <>9__4_0;
public static UnityAction <>9__4_1;
public static UnityAction <>9__4_2;
internal void <Initialize>b__4_0()
{
}
internal void <Initialize>b__4_1()
{
RetryWave();
SetMouseVisibility(show: false);
}
internal void <Initialize>b__4_2()
{
hasRefusedRetryOnDeath = true;
FinalCyberRank val = Object.FindObjectOfType<FinalCyberRank>();
((MonoBehaviour)val).StopAllCoroutines();
val.Appear();
}
}
public static GameObject pauseMenu;
private static GameObject quitDialog;
public static GameObject gameOverDialog;
public static GameObject retryDialog;
public static void Initialize()
{
//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
//IL_0105: Expected O, but got Unknown
//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
//IL_0100: Expected O, but got Unknown
//IL_0132: Unknown result type (might be due to invalid IL or missing references)
//IL_0137: Unknown result type (might be due to invalid IL or missing references)
//IL_013d: Expected O, but got Unknown
//IL_0151: Unknown result type (might be due to invalid IL or missing references)
//IL_0156: Unknown result type (might be due to invalid IL or missing references)
//IL_015c: Expected O, but got Unknown
if ((Object)(object)MonoSingleton<EndlessGrid>.Instance == (Object)null)
{
return;
}
pauseMenu = MonoSingleton<OptionsManager>.Instance.pauseMenu;
if ((Object)(object)MonoSingleton<OptionsManager>.Instance.pauseMenu == (Object)null)
{
return;
}
Transform parent = pauseMenu.transform.parent;
GameObject val = null;
for (int i = 0; i < parent.childCount; i++)
{
GameObject gameObject = ((Component)parent.GetChild(i)).gameObject;
if (((Object)gameObject).name == "PauseMenuDialogs")
{
val = gameObject;
}
}
if ((Object)(object)val == (Object)null)
{
return;
}
quitDialog = ((Component)val.transform.Find("Quit Confirm")).gameObject;
UnityAction val2 = RetryWave;
object obj = <>c.<>9__4_0;
if (obj == null)
{
UnityAction val3 = delegate
{
};
<>c.<>9__4_0 = val3;
obj = (object)val3;
}
retryDialog = CloneDialog("Retry Confirm", "<color=green>RETRY</color>", "CANCEL", "Are you sure you want to\n<color=green>RETRY</color> this wave?", val2, (UnityAction)obj);
object obj2 = <>c.<>9__4_1;
if (obj2 == null)
{
UnityAction val4 = delegate
{
RetryWave();
SetMouseVisibility(show: false);
};
<>c.<>9__4_1 = val4;
obj2 = (object)val4;
}
object obj3 = <>c.<>9__4_2;
if (obj3 == null)
{
UnityAction val5 = delegate
{
hasRefusedRetryOnDeath = true;
FinalCyberRank val6 = Object.FindObjectOfType<FinalCyberRank>();
((MonoBehaviour)val6).StopAllCoroutines();
val6.Appear();
};
<>c.<>9__4_2 = val5;
obj3 = (object)val5;
}
gameOverDialog = CloneDialog("Game Over Confirm", "<color=green>RETRY</color>", "NO", "Do you want to\n<color=green>RETRY</color> this wave?", (UnityAction)obj2, (UnityAction)obj3);
}
public static void ShowDialog(GameObject dialog)
{
SetMouseVisibility(show: true);
dialog.GetComponent<BasicConfirmationDialog>().ShowDialog();
}
private static void SetMouseVisibility(bool show)
{
Cursor.visible = show;
Cursor.lockState = (CursorLockMode)((!show) ? 1 : 0);
}
public static GameObject CloneDialog(string name, string confirmText, string cancelText, string text, UnityAction confirmEvent, UnityAction cancelEvent)
{
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: Expected O, but got Unknown
//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
//IL_00cf: Expected O, but got Unknown
GameObject dialog = Object.Instantiate<GameObject>(quitDialog, quitDialog.transform.parent);
((Object)dialog).name = name;
Transform val = dialog.transform.Find("Panel");
GameObject gameObject = ((Component)val.Find("Cancel")).gameObject;
Button component = gameObject.GetComponent<Button>();
((UnityEvent)component.onClick).AddListener(cancelEvent);
TextMeshProUGUI component2 = ((Component)((Component)component).transform.Find("Text")).GetComponent<TextMeshProUGUI>();
((TMP_Text)component2).text = cancelText;
GameObject gameObject2 = ((Component)val.Find("Confirm")).gameObject;
Button component3 = gameObject2.GetComponent<Button>();
component3.onClick = new ButtonClickedEvent();
((UnityEvent)component3.onClick).AddListener((UnityAction)delegate
{
((Component)dialog.transform.parent.Find("Blocker")).gameObject.SetActive(false);
MonoSingleton<OptionsManager>.Instance.UnPause();
dialog.SetActive(false);
SetMouseVisibility(show: false);
});
((UnityEvent)component3.onClick).AddListener(confirmEvent);
TextMeshProUGUI component4 = ((Component)((Component)component3).transform.Find("Text")).GetComponent<TextMeshProUGUI>();
((TMP_Text)component4).text = confirmText;
TextMeshProUGUI component5 = ((Component)val.Find("Text (2)")).gameObject.GetComponent<TextMeshProUGUI>();
((TMP_Text)component5).text = text;
((Component)((Component)val.Find("Text (1)")).gameObject.GetComponent<TextMeshProUGUI>()).gameObject.SetActive(false);
return dialog;
}
}
private class EndlessGridState
{
private int seed;
private int points;
private int maxPoints;
private int specialAntiBuffer;
private int massAntiBuffer;
private float uncommonAntiBuffer;
private int currentWave;
private int currentPatternNum;
private ArenaPattern[] patterns;
private ArenaPattern[] customPatterns;
private int incompleteBlocks;
private int incompletePrefabs;
private List<Vector2> meleePositions;
private int usedMeleePositions;
private List<Vector2> projectilePositions;
private int usedProjectilePositions;
private int hideousMasses;
public void Save(EndlessGrid grid)
{
Logger.LogInfo((object)"Saved EndlessGrid state");
seed = Random.Range(0, int.MaxValue);
RNG.SetSeed(seed);
currentWave = grid.currentWave;
points = MonoSingleton<EndlessGrid>.Instance.points;
maxPoints = MonoSingleton<EndlessGrid>.Instance.maxPoints;
specialAntiBuffer = MonoSingleton<EndlessGrid>.Instance.specialAntiBuffer;
massAntiBuffer = MonoSingleton<EndlessGrid>.Instance.massAntiBuffer;
uncommonAntiBuffer = MonoSingleton<EndlessGrid>.Instance.uncommonAntiBuffer;
currentPatternNum = MonoSingleton<EndlessGrid>.Instance.currentPatternNum;
patterns = (ArenaPattern[])MonoSingleton<EndlessGrid>.Instance.patterns.Clone();
customPatterns = (ArenaPattern[])MonoSingleton<EndlessGrid>.Instance.customPatterns.Clone();
incompleteBlocks = MonoSingleton<EndlessGrid>.Instance.incompleteBlocks;
usedMeleePositions = MonoSingleton<EndlessGrid>.Instance.usedMeleePositions;
usedProjectilePositions = MonoSingleton<EndlessGrid>.Instance.usedProjectilePositions;
incompletePrefabs = MonoSingleton<EndlessGrid>.Instance.incompletePrefabs;
hideousMasses = MonoSingleton<EndlessGrid>.Instance.hideousMasses;
meleePositions = new List<Vector2>(MonoSingleton<EndlessGrid>.Instance.meleePositions);
projectilePositions = new List<Vector2>(MonoSingleton<EndlessGrid>.Instance.projectilePositions);
}
public void Load(EndlessGrid grid)
{
Logger.LogInfo((object)"Loaded EndlessGrid state");
RNG.SetSeed(seed);
grid.currentWave = currentWave;
MonoSingleton<EndlessGrid>.Instance.points = points;
MonoSingleton<EndlessGrid>.Instance.maxPoints = maxPoints;
MonoSingleton<EndlessGrid>.Instance.specialAntiBuffer = specialAntiBuffer;
MonoSingleton<EndlessGrid>.Instance.massAntiBuffer = massAntiBuffer;
MonoSingleton<EndlessGrid>.Instance.uncommonAntiBuffer = uncommonAntiBuffer;
MonoSingleton<EndlessGrid>.Instance.currentPatternNum = currentPatternNum;
MonoSingleton<EndlessGrid>.Instance.patterns = (ArenaPattern[])patterns.Clone();
MonoSingleton<EndlessGrid>.Instance.customPatterns = (ArenaPattern[])customPatterns.Clone();
MonoSingleton<EndlessGrid>.Instance.incompleteBlocks = incompleteBlocks;
MonoSingleton<EndlessGrid>.Instance.usedMeleePositions = usedMeleePositions;
MonoSingleton<EndlessGrid>.Instance.usedProjectilePositions = usedProjectilePositions;
MonoSingleton<EndlessGrid>.Instance.incompletePrefabs = incompletePrefabs;
MonoSingleton<EndlessGrid>.Instance.hideousMasses = hideousMasses;
MonoSingleton<EndlessGrid>.Instance.meleePositions = new List<Vector2>(meleePositions);
MonoSingleton<EndlessGrid>.Instance.projectilePositions = new List<Vector2>(projectilePositions);
}
}
[HarmonyPatch(typeof(EndlessGrid))]
private class EndlessGridPatch
{
[HarmonyPrefix]
[HarmonyPatch("NextWave")]
private static bool NextWavePrefix()
{
if (!hasCbStarted)
{
Logger.LogInfo((object)"Cybergrind started");
hasCbStarted = true;
}
if (!isRetrying)
{
endlessGridState.Save(MonoSingleton<EndlessGrid>.Instance);
return true;
}
if (isStartup)
{
isStartup = false;
isRetrying = false;
return true;
}
((MonoBehaviour)MonoSingleton<EndlessGrid>.Instance).StopAllCoroutines();
((MonoBehaviour)MonoSingleton<EndlessGrid>.Instance).StartCoroutine(WaitAndCall(ConfigManager.retryStartupTime.Value, delegate
{
endlessGridState.Load(MonoSingleton<EndlessGrid>.Instance);
isStartup = true;
MonoSingleton<EndlessGrid>.Instance.NextWave();
}));
return false;
}
[HarmonyTranspiler]
[HarmonyPatch("GetEnemies")]
private static IEnumerable<CodeInstruction> GetEnemiesTranspiler(IEnumerable<CodeInstruction> instructions)
{
TranspileRandom(instructions);
return instructions;
}
[HarmonyTranspiler]
[HarmonyPatch("GetNextEnemy")]
private static IEnumerable<CodeInstruction> GetNextEnemyTranspiler(IEnumerable<CodeInstruction> instructions)
{
TranspileRandom(instructions);
return instructions;
}
[HarmonyTranspiler]
[HarmonyPatch("ShuffleDecks")]
private static IEnumerable<CodeInstruction> ShuffleDecksTranspiler(IEnumerable<CodeInstruction> instructions)
{
TranspileRandom(instructions);
return instructions;
}
[HarmonyTranspiler]
[HarmonyPatch("SpawnUncommons")]
private static IEnumerable<CodeInstruction> SpawnUncommonsTranspiler(IEnumerable<CodeInstruction> instructions)
{
TranspileRandom(instructions);
return instructions;
}
}
[HarmonyPatch(typeof(FinalCyberRank))]
private class FinalCyberRankPatch
{
[HarmonyPrefix]
[HarmonyPatch("GameOver")]
private static bool GameOverPrefix(FinalCyberRank __instance)
{
if (!hasRefusedRetryOnDeath && hasCbStarted)
{
((MonoBehaviour)__instance).StopAllCoroutines();
((MonoBehaviour)__instance).StartCoroutine(WaitAndCall(1f, delegate
{
DialogManager.ShowDialog(DialogManager.gameOverDialog);
}));
}
return true;
}
[HarmonyPrefix]
[HarmonyPatch("Appear")]
private static bool AppearPrefix(FinalCyberRank __instance)
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
if (hasRefusedRetryOnDeath || !hasCbStarted)
{
Scene activeScene = SceneManager.GetActiveScene();
GameObject[] rootGameObjects = ((Scene)(ref activeScene)).GetRootGameObjects();
GameObject[] array = rootGameObjects;
foreach (GameObject val in array)
{
if (((Object)val).name == "EndMusic")
{
val.SetActive(true);
}
}
return true;
}
return false;
}
}
[HarmonyPatch(typeof(OptionsManager))]
private class OptionsManagerPatch
{
[Serializable]
[CompilerGenerated]
private sealed class <>c
{
public static readonly <>c <>9 = new <>c();
public static UnityAction <>9__1_0;
internal void <StartPostfix>b__1_0()
{
FinalCyberRank val = Object.FindObjectOfType<FinalCyberRank>();
if (MonoSingleton<CheatsController>.Instance.cheatsEnabled || val.gameOver)
{
MonoSingleton<OptionsManager>.Instance.UnPause();
RetryWave();
}
else
{
DialogManager.ShowDialog(DialogManager.retryDialog);
}
}
}
private static GameObject buttonObject;
[HarmonyPostfix]
[HarmonyPatch("Start")]
private static void StartPostfix()
{
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Expected O, but got Unknown
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Expected O, but got Unknown
DialogManager.Initialize();
if ((Object)(object)DialogManager.pauseMenu == (Object)null)
{
return;
}
Button componentInChildren = DialogManager.pauseMenu.GetComponentInChildren<Button>(true);
buttonObject = Object.Instantiate<GameObject>(((Component)componentInChildren).gameObject, ((Component)componentInChildren).transform.parent);
((Object)buttonObject).name = "CGRetryWave Button";
Button component = buttonObject.GetComponent<Button>();
component.onClick = new ButtonClickedEvent();
ButtonClickedEvent onClick = component.onClick;
object obj = <>c.<>9__1_0;
if (obj == null)
{
UnityAction val = delegate
{
FinalCyberRank val2 = Object.FindObjectOfType<FinalCyberRank>();
if (MonoSingleton<CheatsController>.Instance.cheatsEnabled || val2.gameOver)
{
MonoSingleton<OptionsManager>.Instance.UnPause();
RetryWave();
}
else
{
DialogManager.ShowDialog(DialogManager.retryDialog);
}
};
<>c.<>9__1_0 = val;
obj = (object)val;
}
((UnityEvent)onClick).AddListener((UnityAction)obj);
RectTransform component2 = buttonObject.GetComponent<RectTransform>();
component2.anchoredPosition += new Vector2(0f, -60f);
}
[HarmonyPostfix]
[HarmonyPatch("Pause")]
private static void PausePostfix()
{
if ((Object)(object)MonoSingleton<EndlessGrid>.Instance == (Object)null)
{
return;
}
if (Object.op_Implicit((Object)(object)buttonObject))
{
buttonObject.SetActive(hasCbStarted);
TextMeshProUGUI componentInChildren = buttonObject.GetComponentInChildren<TextMeshProUGUI>(true);
Button component = buttonObject.GetComponent<Button>();
if (MonoSingleton<EndlessGrid>.Instance.incompleteBlocks == 0 && MonoSingleton<EndlessGrid>.Instance.incompletePrefabs == 0)
{
((TMP_Text)componentInChildren).text = "<color=green>RETRY WAVE</color>";
((Behaviour)component).enabled = true;
}
else
{
((TMP_Text)componentInChildren).text = "<color=red>LOADING WAVE</color>";
((Behaviour)component).enabled = false;
}
}
if ((Object)(object)MonoSingleton<OptionsManager>.Instance.pauseMenu == (Object)null)
{
return;
}
Button[] componentsInChildren = MonoSingleton<OptionsManager>.Instance.pauseMenu.GetComponentsInChildren<Button>();
Button[] array = componentsInChildren;
foreach (Button val in array)
{
TextMeshProUGUI componentInChildren2 = ((Component)val).GetComponentInChildren<TextMeshProUGUI>(true);
if ((Object)(object)componentInChildren2 != (Object)null && ((TMP_Text)componentInChildren2).text.ToUpper() == "CHECKPOINT")
{
((Component)val).gameObject.SetActive(!hasCbStarted);
}
}
}
}
[HarmonyPatch(typeof(NewMovement))]
private class NewMovementPatch
{
[HarmonyPrefix]
[HarmonyPatch("Start")]
private static void StartPrefix()
{
hasCbStarted = false;
hasRefusedRetryOnDeath = false;
}
}
[HarmonyPatch(typeof(BasicConfirmationDialog))]
private class BasicConfirmationDialogPatch
{
[HarmonyPrefix]
[HarmonyPatch("Update")]
private static bool UpdatePrefix(BasicConfirmationDialog __instance)
{
if (((Object)((Component)__instance).gameObject).name == "Game Over Confirm")
{
return false;
}
return true;
}
}
private const string ID = "51.CGRetry";
private const string NAME = "CGRetry";
private const string VERSION = "1.0.0";
private static ManualLogSource Logger;
private static EndlessGridState endlessGridState = new EndlessGridState();
private static bool isRetrying = false;
private static bool isStartup = false;
private static bool hasCbStarted = false;
private static bool hasRefusedRetryOnDeath = false;
private void Awake()
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Expected O, but got Unknown
Logger = ((BaseUnityPlugin)this).Logger;
ConfigManager.Initialize(((BaseUnityPlugin)this).Config);
Harmony val = new Harmony("CGRetry");
val.PatchAll();
Logger.LogInfo((object)"CGRetry loaded");
}
private static void TranspileRandom(IEnumerable<CodeInstruction> instructions)
{
MethodInfo methodInfo = AccessTools.Method(typeof(Random), "Range", new Type[2]
{
typeof(int),
typeof(int)
}, (Type[])null);
MethodInfo methodInfo2 = AccessTools.Method(typeof(Random), "Range", new Type[2]
{
typeof(float),
typeof(float)
}, (Type[])null);
MethodInfo operand = AccessTools.Method(typeof(RNG), "RangeInt", new Type[2]
{
typeof(int),
typeof(int)
}, (Type[])null);
MethodInfo operand2 = AccessTools.Method(typeof(RNG), "RangeFloat", new Type[2]
{
typeof(float),
typeof(float)
}, (Type[])null);
foreach (CodeInstruction instruction in instructions)
{
if (CodeInstructionExtensions.Calls(instruction, methodInfo))
{
instruction.operand = operand;
}
if (CodeInstructionExtensions.Calls(instruction, methodInfo2))
{
instruction.operand = operand2;
}
}
}
private static void RetryWave()
{
MonoSingleton<CheatsController>.Instance.ActivateCheats();
ResetGame();
isRetrying = true;
MonoSingleton<EndlessGrid>.Instance.NextWave();
}
private static void ResetGame()
{
//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
//IL_032d: Unknown result type (might be due to invalid IL or missing references)
//IL_0332: Unknown result type (might be due to invalid IL or missing references)
hasRefusedRetryOnDeath = false;
GameObject currentWeapon = MonoSingleton<GunControl>.Instance.currentWeapon;
if ((Object)(object)currentWeapon != (Object)null)
{
ShotgunHammer component = currentWeapon.GetComponent<ShotgunHammer>();
if ((Object)(object)component != (Object)null)
{
component.launchPlayer = false;
}
}
MonoSingleton<EndlessGrid>.Instance.incompleteBlocks = 999;
MonoSingleton<EndlessGrid>.Instance.anw.deadEnemies = 0;
((MonoBehaviour)MonoSingleton<EndlessGrid>.Instance).CancelInvoke();
((Behaviour)MonoSingleton<NewMovement>.Instance).enabled = true;
if ((Object)(object)MonoSingleton<NewMovement>.Instance.ridingRocket != (Object)null)
{
Object.Destroy((Object)(object)((Component)MonoSingleton<NewMovement>.Instance.ridingRocket).gameObject);
MonoSingleton<NewMovement>.Instance.ridingRocket = null;
}
MonoSingleton<NewMovement>.Instance.StopSlide();
MonoSingleton<NewMovement>.Instance.Respawn();
MonoSingleton<NewMovement>.Instance.rb.position = new Vector3(0.01f, 100f, 62.5f);
MonoSingleton<NewMovement>.Instance.rb.velocity = Vector3.zero;
MonoSingleton<StyleHUD>.Instance.ResetAllFreshness();
MonoSingleton<StyleHUD>.Instance.rankIndex = ConfigManager.retryStartRank.Value;
MonoSingleton<StyleHUD>.Instance.currentMeter = (float)MonoSingleton<StyleHUD>.Instance.currentRank.maxMeter - 0.01f;
MonoSingleton<StyleHUD>.Instance.AscendRank();
MonoSingleton<CameraController>.Instance.activated = true;
MonoSingleton<CameraController>.Instance.StopShake();
MonoSingleton<CameraController>.Instance.rotationX = 0f;
MonoSingleton<CameraController>.Instance.rotationY = 0f;
MonoSingleton<StatsManager>.Instance.StartTimer();
MonoSingleton<StatsManager>.Instance.UnhideShit();
FinalCyberRank val = Object.FindObjectOfType<FinalCyberRank>();
val.gameOver = false;
val.i = 0;
((Component)((Component)((Component)val.friendContainer.transform.parent).gameObject.transform.parent).gameObject.transform.parent).gameObject.SetActive(false);
((Component)val.globalContainer.transform.parent).gameObject.SetActive(false);
GameObject[] toAppear = val.toAppear;
foreach (GameObject val2 in toAppear)
{
val2.SetActive(false);
}
val.complete = false;
val.countTime = false;
val.countWaves = false;
val.countKills = false;
val.countStyle = false;
((MonoBehaviour)val).StopAllCoroutines();
MonoSingleton<TimeController>.Instance.controlTimeScale = true;
DestroyAll<Projectile>();
DestroyAll<ContinuousBeam>();
DestroyAll<GroundWave>();
DestroyAll<Magnet>();
DestroyAll<VirtueInsignia>();
DestroyAll<Pincer>();
List<GameObject> spawnedEnemies = MonoSingleton<EndlessGrid>.Instance.spawnedEnemies;
for (int num = spawnedEnemies.Count - 1; num >= 0; num--)
{
if ((Object)(object)spawnedEnemies[num] != (Object)null)
{
Object.Destroy((Object)(object)spawnedEnemies[num]);
}
}
spawnedEnemies.Clear();
val.wasPaused = false;
MonoSingleton<AudioMixerController>.Instance.allSound.SetFloat("allVolume", MonoSingleton<AudioMixerController>.Instance.CalculateVolume(MonoSingleton<AudioMixerController>.Instance.sfxVolume));
MonoSingleton<AudioMixerController>.Instance.musicSound.SetFloat("allVolume", MonoSingleton<AudioMixerController>.Instance.CalculateVolume(MonoSingleton<AudioMixerController>.Instance.musicVolume));
Scene activeScene = SceneManager.GetActiveScene();
GameObject[] rootGameObjects = ((Scene)(ref activeScene)).GetRootGameObjects();
GameObject[] array = rootGameObjects;
foreach (GameObject val3 in array)
{
if (((Object)val3).name == "EndMusic")
{
val3.SetActive(false);
}
}
}
private static void DestroyAll<T>() where T : Component
{
T[] array = Object.FindObjectsOfType<T>();
if (array.Length == 0)
{
return;
}
T[] array2 = array;
foreach (T val in array2)
{
if ((Object)(object)val != (Object)null)
{
Object.Destroy((Object)(object)((Component)val).gameObject);
}
}
}
private static IEnumerator WaitAndCall(float time, Action work)
{
yield return (object)new WaitForSecondsRealtime(time);
work();
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
