using System; using System.CodeDom.Compiler; using System.Collections; using System.Collections.Generic; using System.ComponentModel; using System.Diagnostics; using System.Globalization; using System.Reflection; using System.Resources; using System.Runtime.CompilerServices; using System.Runtime.Versioning; using System.Security; using System.Security.Permissions; using BepInEx; using BepInEx.Configuration; using BepInEx.Logging; using Microsoft.CodeAnalysis; using On.RoR2; using On.RoR2.UI; using RoR2; using RoR2.Navigation; using RoR2.UI; using TMPro; using UnityEngine; 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: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")] [assembly: AssemblyCompany("OutOfBoundsSafe")] [assembly: AssemblyConfiguration("Debug")] [assembly: AssemblyFileVersion("1.0.0.0")] [assembly: AssemblyInformationalVersion("1.0.0+7d47a9052ef02949971daab163c20ecb273821bc")] [assembly: AssemblyProduct("OutOfBoundsSafe")] [assembly: AssemblyTitle("OutOfBoundsSafe")] [assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)] [assembly: AssemblyVersion("1.0.0.0")] [module: UnverifiableCode] [module: RefSafetyRules(11)] namespace Microsoft.CodeAnalysis { [CompilerGenerated] [Embedded] internal sealed class EmbeddedAttribute : Attribute { } } namespace System.Runtime.CompilerServices { [CompilerGenerated] [Embedded] [AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)] internal sealed class RefSafetyRulesAttribute : Attribute { public readonly int Version; public RefSafetyRulesAttribute(int P_0) { Version = P_0; } } } namespace OutOfBoundsSafe { internal static class Assets { [CompilerGenerated] private static class <>O { public static hook_Awake <0>__MakeTooltip; public static hook_Awake <1>__MakeSnakeIcon; } private static string Snake = "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"; private static Sprite SnakeSprite; public static GameObject Tooltip; public static GameObject SnakeIcon; public static Image SnakeImage; public static void Init() { //IL_0017: Unknown result type (might be due to invalid IL or missing references) //IL_001c: Unknown result type (might be due to invalid IL or missing references) //IL_0022: Expected O, but got Unknown //IL_0038: Unknown result type (might be due to invalid IL or missing references) //IL_003d: Unknown result type (might be due to invalid IL or missing references) //IL_0043: Expected O, but got Unknown MakeSnakeSprite(); object obj = <>O.<0>__MakeTooltip; if (obj == null) { hook_Awake val = MakeTooltip; <>O.<0>__MakeTooltip = val; obj = (object)val; } HUDTutorialController.Awake += (hook_Awake)obj; object obj2 = <>O.<1>__MakeSnakeIcon; if (obj2 == null) { hook_Awake val2 = MakeSnakeIcon; <>O.<1>__MakeSnakeIcon = val2; obj2 = (object)val2; } HUD.Awake += (hook_Awake)obj2; } private static void MakeSnakeSprite() { //IL_000e: Unknown result type (might be due to invalid IL or missing references) //IL_0014: Expected O, but got Unknown //IL_0035: Unknown result type (might be due to invalid IL or missing references) //IL_0044: Unknown result type (might be due to invalid IL or missing references) byte[] array = Convert.FromBase64String(Snake); Texture2D val = new Texture2D(2, 2); ImageConversion.LoadImage(val, array); SnakeSprite = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f)); } private static void MakeTooltip(orig_Awake orig, HUDTutorialController self) { //IL_006c: Unknown result type (might be due to invalid IL or missing references) orig.Invoke(self); if (OutOfBoundsSafe.tooltipShown) { return; } GameObject remoteOpTutorialObject = self.remoteOpTutorialObject; if ((Object)(object)remoteOpTutorialObject != (Object)null) { Tooltip = Object.Instantiate(remoteOpTutorialObject, remoteOpTutorialObject.transform.parent); Image[] componentsInChildren = Tooltip.GetComponentsInChildren(); foreach (Image val in componentsInChildren) { ((Graphic)val).color = new Color(1f, 0.8f, 1f, 1f); } } } private static void MakeSnakeIcon(orig_Awake orig, HUD self) { orig.Invoke(self); if (!OutOfBoundsSafe.tooltipShown) { GameObject sprintIconObject = self.sprintIcon.sprintIconObject; if ((Object)(object)sprintIconObject != (Object)null) { SnakeIcon = Object.Instantiate(sprintIconObject, sprintIconObject.transform.parent); SnakeImage = SnakeIcon.GetComponent(); SnakeImage.sprite = SnakeSprite; SnakeImage.preserveAspect = true; SnakeIcon.SetActive(false); } } } } internal static class Log { private static ManualLogSource _logSource; internal static void Init(ManualLogSource logSource) { _logSource = logSource; } internal static void Debug(object data) { _logSource.LogDebug(data); } internal static void Error(object data) { _logSource.LogError(data); } internal static void Fatal(object data) { _logSource.LogFatal(data); } internal static void Info(object data) { _logSource.LogInfo(data); } internal static void Message(object data) { _logSource.LogMessage(data); } internal static void Warning(object data) { _logSource.LogWarning(data); } } [BepInPlugin("bouncyshield.OutOfBoundsSafe", "OutOfBoundsSafe", "1.1.0")] public class OutOfBoundsSafe : BaseUnityPlugin { [Serializable] [CompilerGenerated] private sealed class <>c { public static readonly <>c <>9 = new <>c(); public static hook_Awake <>9__5_2; internal void b__5_2(orig_Awake orig, Run self) { tooltipShown = disableTooltip.Value; orig.Invoke(self); } } public const string PluginGUID = "bouncyshield.OutOfBoundsSafe"; public const string PluginAuthor = "bouncyshield"; public const string PluginName = "OutOfBoundsSafe"; public const string PluginVersion = "1.1.0"; private bool inPod = false; private List Basket = new List(); private List tethered = new List(); private float yBound = float.MaxValue; private bool imscared = false; public static bool tooltipShown; private int tooltipTimer = 0; private float alpha; public static ConfigEntry breakKey; public static ConfigEntry buffer; public static ConfigEntry disableTooltip; public void Awake() { Log.Init(((BaseUnityPlugin)this).Logger); Configs(); Hooks(); Assets.Init(); } private void Hooks() { //IL_0008: Unknown result type (might be due to invalid IL or missing references) //IL_0012: Expected O, but got Unknown //IL_002c: Unknown result type (might be due to invalid IL or missing references) //IL_0036: Expected O, but got Unknown //IL_003e: Unknown result type (might be due to invalid IL or missing references) //IL_0048: Expected O, but got Unknown //IL_005d: Unknown result type (might be due to invalid IL or missing references) //IL_0062: Unknown result type (might be due to invalid IL or missing references) //IL_0068: Expected O, but got Unknown MapZone.TryZoneStart += new hook_TryZoneStart(HitBound); Stage.onStageStartGlobal += OnStageStartGlobal; SurvivorPodController.OnPassengerEnter += (hook_OnPassengerEnter)delegate(orig_OnPassengerEnter orig, SurvivorPodController a, GameObject b) { inPod = true; orig.Invoke(a, b); }; SurvivorPodController.OnPassengerExit += (hook_OnPassengerExit)delegate(orig_OnPassengerExit orig, SurvivorPodController a, GameObject b) { inPod = false; orig.Invoke(a, b); }; object obj = <>c.<>9__5_2; if (obj == null) { hook_Awake val = delegate(orig_Awake orig, Run self) { tooltipShown = disableTooltip.Value; orig.Invoke(self); }; <>c.<>9__5_2 = val; obj = (object)val; } Run.Awake += (hook_Awake)obj; } private void OnStageStartGlobal(Stage stage) { ClearBasket(stage); GetBound(stage); } private void HitBound(orig_TryZoneStart orig, MapZone self, Collider other) { //IL_003f: Unknown result type (might be due to invalid IL or missing references) //IL_0044: Unknown result type (might be due to invalid IL or missing references) if (inPod) { Log.Debug("SurvivorPod passed through " + ((Object)((Component)self).gameObject).name); return; } string text = ((Object)((Component)self).gameObject).name.ToLower(); Scene activeScene = SceneManager.GetActiveScene(); string name = ((Scene)(ref activeScene)).name; bool flag = name == "limbo" || name == "mysteryworld" || name.Contains("artifactworld") || !(text.Contains("orb") | text.Contains("altar") | (text.Contains("map") && !text.Contains("holder")) | text.Contains("kickout") | text.Contains("fightstart")); CharacterBody component = ((Component)other).GetComponent(); bool flag2 = component != null && component.isPlayerControlled; if (flag && flag2) { Basket.Add(((MonoBehaviour)this).StartCoroutine(Tether(orig, self, other))); } else if (!flag && flag2) { Log.Debug("Allowed " + ((Object)((Component)self).gameObject).name + " to warp " + ((Object)other).name); orig.Invoke(self, other); } else { orig.Invoke(self, other); } } private void ClearBasket(Stage x) { Basket.Clear(); } private IEnumerator Tether(orig_TryZoneStart orig, MapZone self, Collider other) { if (tethered.Contains(other)) { yield break; } tethered.Add(other); CheckTooltip(); string tetherName = ((Object)other).name + " to " + ((Object)self).name; Log.Info("Tether " + tetherName + " created"); string breakReason; while (true) { if ((Object)(object)self == (Object)null) { breakReason = "MapZone null"; break; } if ((Object)(object)other == (Object)null) { breakReason = "Collider null"; break; } if (((Component)other).transform.localPosition.y < yBound) { breakReason = "fell OOB"; orig.Invoke(self, other); break; } if (imscared) { breakReason = "EEK!"; orig.Invoke(self, other); imscared = false; break; } if (Object.op_Implicit((Object)(object)Assets.Tooltip)) { tooltipTimer++; if (tooltipTimer >= 30) { Assets.Tooltip.SetActive(false); } } yield return (object)new WaitForSeconds(0.5f); } if (Object.op_Implicit((Object)(object)Assets.Tooltip) && Assets.Tooltip.activeInHierarchy) { Assets.Tooltip.SetActive(false); Snake(); } tethered.Remove(other); Log.Info("Tether " + tetherName + " broke (" + breakReason + ")"); } private void GetBound(Stage stage) { //IL_0035: Unknown result type (might be due to invalid IL or missing references) //IL_003a: Unknown result type (might be due to invalid IL or missing references) //IL_003d: Unknown result type (might be due to invalid IL or missing references) //IL_003f: Unknown result type (might be due to invalid IL or missing references) //IL_0053: Unknown result type (might be due to invalid IL or missing references) //IL_0055: Unknown result type (might be due to invalid IL or missing references) float num = float.MaxValue; SceneInfo instance = SceneInfo.instance; NodeGraph val = ((instance != null) ? instance.groundNodes : null); if ((Object)(object)val != (Object)null) { Node[] nodes = val.nodes; foreach (Node val2 in nodes) { if (val2.position.y < num) { num = val2.position.y; } } } if (num == float.MaxValue) { Log.Warning("Could not find a lower bound for the scene, OOB mechanics will not work"); } else { Log.Debug($"Lower bound at y = {num} (- {buffer.Value})"); } yBound = num - buffer.Value; } public void Update() { //IL_0006: Unknown result type (might be due to invalid IL or missing references) if (Input.GetKeyDown(breakKey.Value) && tethered.Count > 0) { imscared = true; } } private void CheckTooltip() { //IL_003b: Unknown result type (might be due to invalid IL or missing references) if (!tooltipShown && (Object)(object)Assets.Tooltip != (Object)null) { Assets.Tooltip.SetActive(true); ((TMP_Text)Assets.Tooltip.GetComponentInChildren()).text = $"Press {breakKey.Value} to return in bounds!"; tooltipShown = true; } } private void Snake() { if ((Object)(object)Assets.SnakeIcon != (Object)null) { Assets.SnakeIcon.SetActive(true); ((MonoBehaviour)this).StartCoroutine(Fade()); } } private IEnumerator Fade() { alpha = 1f; ((Graphic)Assets.SnakeImage).color = new Color(1f, 1f, 1f, alpha); while (alpha >= 0f) { yield return (object)new WaitForSeconds(0.04f); alpha -= 0.01f * (2f - alpha); try { ((Graphic)Assets.SnakeImage).color = new Color(1f, 1f, 1f, alpha); } catch { } } } private void Configs() { breakKey = ((BaseUnityPlugin)this).Config.Bind("OOBSafe", "Panic Button", (KeyCode)98, "Key to manually return in bounds"); buffer = ((BaseUnityPlugin)this).Config.Bind("OOBSafe", "Fall Buffer", 600f, "How far you can fall out of the map (in y coords) before you are automatically returned in bounds."); disableTooltip = ((BaseUnityPlugin)this).Config.Bind("OOBSafe", "Disable Tooltip", false, "Disables the 15 second tooltip shown on first boundary break per run"); } } } namespace OutOfBoundsSafe.Properties { [GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")] [DebuggerNonUserCode] [CompilerGenerated] internal class Resources { private static ResourceManager resourceMan; private static CultureInfo resourceCulture; [EditorBrowsable(EditorBrowsableState.Advanced)] internal static ResourceManager ResourceManager { get { if (resourceMan == null) { ResourceManager resourceManager = new ResourceManager("OutOfBoundsSafe.Properties.Resources", typeof(Resources).Assembly); resourceMan = resourceManager; } return resourceMan; } } [EditorBrowsable(EditorBrowsableState.Advanced)] internal static CultureInfo Culture { get { return resourceCulture; } set { resourceCulture = value; } } internal Resources() { } } }