using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;
using Zorro.Core;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("MoreAscents")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("MoreAscents")]
[assembly: AssemblyCopyright("Copyright © 2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("7639095B-2BDE-4375-A67F-ABF1BD416340")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace MoreAscents;
internal static class AchievementManagerPatches
{
[HarmonyPatch(typeof(AchievementManager), "GetMaxAscent")]
internal static class GetMaxAscent
{
[HarmonyPostfix]
internal static void Postfix(ref int __result)
{
__result = Plugin.ascentsUnlocked.Value;
if (__result > SingletonAsset<AscentData>.Instance.ascents.Count - 1)
{
__result = SingletonAsset<AscentData>.Instance.ascents.Count - 1;
}
}
}
[HarmonyPatch(typeof(AchievementManager), "Start")]
internal static class Start
{
[HarmonyPrefix]
internal static void Prefix()
{
Plugin.Init();
}
}
[HarmonyPatch(typeof(AchievementManager), "SetSteamStat", new Type[]
{
typeof(STEAMSTATTYPE),
typeof(int)
})]
internal static class SetSteamStat
{
[HarmonyPrefix]
internal static void Prefix(STEAMSTATTYPE steamStatType, ref int value)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0004: Invalid comparison between Unknown and I4
if ((int)steamStatType == 13)
{
Plugin.ascentsUnlocked.Value = value;
if (value > AscentGimmickHandler.BaseAscents - 1)
{
value = AscentGimmickHandler.BaseAscents - 1;
}
}
}
}
}
public class AfflictionGimmick : AscentGimmick
{
public override string GetTitle()
{
return "Ascent 10";
}
public override string GetDescription()
{
return "You're more vulnerable to everything but Injuries, Hunger and Weight.";
}
public override float AfflictionMultiplier(CharacterAfflictions affliction, STATUSTYPE statusType, float amount)
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Invalid comparison between Unknown and I4
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Invalid comparison between Unknown and I4
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Invalid comparison between Unknown and I4
if (!affliction.character.IsLocal)
{
return 0f;
}
if ((int)statusType == 0 || (int)statusType == 1 || (int)statusType == 7 || (int)statusType == 2)
{
return 0f;
}
return 2f;
}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class CurrentAscentSetterPatch
{
[HarmonyPrefix]
public static void Prefix(int value)
{
AscentGimmickHandler.DisableGimmicks();
AscentGimmickHandler.MarkGimmicksAsActive(value + 2);
}
}
public class AscentGimmick
{
public AscentStruct _ascentData;
public bool active;
public virtual string GetTitle()
{
return "";
}
public virtual string GetDescription()
{
return "";
}
public virtual Color GetColor()
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
return Color.red;
}
public virtual string GetTitleReward()
{
return "";
}
public virtual void CharacterPassedOut(Character character)
{
}
public virtual void OnLavaExisted(Lava lava)
{
}
public virtual void OnFogInitNewSphere(OrbFogHandler __instance)
{
}
public virtual void OnCharacterFall(Character character)
{
}
public virtual void RespawnChestExisted(Spawner chest)
{
}
public virtual void OnFinishCooking(ItemCooking itemCooking)
{
}
public virtual void SpawnerSpawnItems(Spawner spawner, ref List<Transform> spawnSpots)
{
}
public virtual void OnGrabbedCharacter(Character thisCharacter)
{
}
public virtual void OnUpdateNormalStatuses(Character character)
{
}
public virtual void Update()
{
}
public virtual float AfflictionMultiplier(CharacterAfflictions afflictions, STATUSTYPE statusType, float amount)
{
return 0f;
}
}
public static class AscentGimmickHandler
{
internal static readonly List<AscentGimmick> gimmicks = new List<AscentGimmick>();
private static readonly List<AscentInstanceData> pendingDatas = new List<AscentInstanceData>();
private static bool HasInitialized = false;
internal static int BaseAscents { get; private set; } = -1;
internal static void MarkGimmicksAsActive(int ascentIndex)
{
int num = 0;
foreach (AscentInstanceData ascent in SingletonAsset<AscentData>.Instance.ascents)
{
AscentGimmick gimmickByData = GetGimmickByData(ascent);
if (num <= ascentIndex && gimmickByData != null)
{
gimmickByData.active = true;
Plugin.Logger.LogWarning((object)("enabled gimmick " + gimmickByData.GetType().Name + " [" + gimmickByData.GetTitle() + "]!"));
}
num++;
}
}
public static AscentGimmick GetGimmickByData(AscentInstanceData data)
{
foreach (AscentGimmick gimmick in gimmicks)
{
if (gimmick._ascentData.data == data)
{
return gimmick;
}
}
return null;
}
internal static void DisableGimmicks()
{
foreach (AscentGimmick gimmick in gimmicks)
{
gimmick.active = false;
}
}
internal static int GetBaseAscentCount()
{
if (BaseAscents == -1)
{
BaseAscents = SingletonAsset<AscentData>.Instance.ascents.Count;
}
return BaseAscents;
}
internal static void Initialize()
{
if (HasInitialized)
{
Plugin.Logger.LogError((object)"already initialized");
return;
}
HasInitialized = true;
AscentData instance = SingletonAsset<AscentData>.Instance;
List<AscentInstanceData> ascents = instance.ascents;
List<AscentInstanceData> list = new List<AscentInstanceData>();
Plugin.Logger.LogInfo((object)$"initializing with ({pendingDatas.Count} custom) and ({ascents.Count} base)");
foreach (AscentInstanceData item in ascents)
{
HotLoadAscentInstanceData(list, item);
}
foreach (AscentInstanceData pendingData in pendingDatas)
{
HotLoadAscentInstanceData(list, pendingData);
}
instance.ascents = list;
}
private static void HotLoadAscentInstanceData(List<AscentInstanceData> targetList, AscentInstanceData data)
{
if (data.titleReward == "")
{
data.titleReward = data.title + " Conqueror";
}
targetList.Add(data);
}
public static void RegisterAscent<T>() where T : AscentGimmick
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: 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)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Expected O, but got Unknown
AscentGimmick ascentGimmick = Activator.CreateInstance<T>();
AscentInstanceData val = new AscentInstanceData
{
title = ascentGimmick.GetTitle(),
description = ascentGimmick.GetDescription(),
titleReward = ascentGimmick.GetTitleReward(),
color = ascentGimmick.GetColor(),
sashSprite = SingletonAsset<AscentData>.Instance.ascents[0].sashSprite
};
ascentGimmick._ascentData = new AscentStruct
{
data = val,
order = 9 + (gimmicks.Count + 1)
};
gimmicks.Add(ascentGimmick);
if (HasInitialized)
{
HotLoadAscentInstanceData(SingletonAsset<AscentData>.Instance.ascents, val);
Plugin.Logger.LogInfo((object)("Hot loaded " + val.title + "!"));
return;
}
pendingDatas.Add(val);
Plugin.Logger.LogInfo((object)("Queued " + val.title));
AddIdentityTranslation<T>(ascentGimmick.GetTitle(), ascentGimmick.GetTitle());
AddIdentityTranslation<T>("desc_" + ascentGimmick.GetTitle(), ascentGimmick.GetDescription());
}
[CompilerGenerated]
internal static void AddIdentityTranslation<T>(string key, string val) where T : AscentGimmick
{
if (string.IsNullOrWhiteSpace(key))
{
throw new NotImplementedException($"translation was empty?? {typeof(T)}");
}
LocalizedText.mainTable.Add(key.ToUpperInvariant(), Enumerable.Repeat(val.ToUpperInvariant(), 14).ToList());
}
}
public struct AscentStruct
{
public AscentInstanceData data;
public int order;
}
public class BingBongGimmick : AscentGimmick
{
private static float SinceLastShake;
public override string GetDescription()
{
return "Bing Bong calls upon an evil force if not given attention.";
}
public override string GetTitle()
{
return "Chaos 4";
}
public override void Update()
{
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Invalid comparison between Unknown and I4
float deltaTime = Time.deltaTime;
SinceLastShake += deltaTime;
Item heldBingBongItem = BingBongPatches.heldBingBongItem;
if ((Object)(object)heldBingBongItem != (Object)null && (int)heldBingBongItem.itemState == 1)
{
BingBongMechanics.BingBongUnheldFor = 0f;
}
else
{
BingBongMechanics.BingBongUnheldFor += deltaTime;
}
foreach (Character allCharacter in Character.AllCharacters)
{
if (allCharacter.IsLocal)
{
if (allCharacter.data.passedOutOnTheBeach > 0f)
{
BingBongMechanics.BingBongUnheldFor = 0f;
break;
}
if (BingBongMechanics.BingBongUnheldFor > 10f && BingBongMechanics.BingBongUnheldFor <= 15f && SinceLastShake > 0f)
{
SinceLastShake = 0f;
GamefeelHandler.instance.AddPerlinShake(0.7f, 0.15f, 15f);
}
if (BingBongMechanics.BingBongUnheldFor >= 15f)
{
allCharacter.refs.afflictions.AddStatus((STATUSTYPE)4, 0.05f * Time.deltaTime, false, true, true);
break;
}
}
}
}
}
internal class BingBongMechanics
{
internal static float BingBongUnheldFor;
}
internal class BingBongPatches
{
[HarmonyPatch(typeof(CharacterData), "set_currentItem")]
internal static class Patch
{
[HarmonyPrefix]
internal static void Prefix(Item value)
{
if ((Object)(object)value != (Object)null && (Object)(object)value != (Object)null)
{
bool? flag = value.UIData?.itemName?.ToLowerInvariant()?.Equals("bing bong");
bool? flag2 = flag;
if (flag2 == true)
{
heldBingBongItem = value;
return;
}
}
heldBingBongItem = null;
}
}
internal static Item heldBingBongItem;
}
[HarmonyPatch(typeof(BoardingPass), "UpdateAscent")]
internal static class BoardingInitilizePatch
{
internal static void Prefix(BoardingPass __instance)
{
if (Input.GetKey((KeyCode)108))
{
Singleton<AchievementManager>.Instance.SetSteamStat((STEAMSTATTYPE)13, SingletonAsset<AscentData>.Instance.ascents.Count - 3);
}
}
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> inputIL)
{
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: Expected O, but got Unknown
bool flag = false;
List<CodeInstruction> list = new List<CodeInstruction>(inputIL);
for (int i = 0; i < list.Count - 4; i++)
{
if (list[i].opcode == OpCodes.Ldc_I4_8 && list[i + 1].opcode == OpCodes.Ldarg_0 && list[i + 3].opcode == OpCodes.Call)
{
if (flag)
{
throw new Exception("already patched boardingpass!! why are there 2+ calls of this shape?");
}
list[i] = new CodeInstruction(OpCodes.Ldc_I4, (object)(SingletonAsset<AscentData>.Instance.ascents.Count - 3));
flag = true;
}
}
if (!flag)
{
throw new Exception("Couldnt apply boardingpass patch :(");
}
return list.AsEnumerable();
}
}
internal static class CharacterCustomizationPatches
{
[HarmonyPatch(typeof(CharacterCustomization), "SetCharacterSash")]
internal static class SetCharacterSash
{
[HarmonyPrefix]
internal static void Prefix(ref int index)
{
if (index > AscentGimmickHandler.BaseAscents - 2)
{
index = AscentGimmickHandler.BaseAscents - 2;
}
}
}
}
public class CharacterPatches
{
[HarmonyPatch(typeof(CharacterMovement), "CheckFallDamage")]
public static class CheckFallDamage
{
public static bool InFallDamage;
[HarmonyPrefix]
public static void Prefix(CharacterMovement __instance)
{
InFallDamage = true;
}
[HarmonyPostfix]
public static void Postfix(CharacterMovement __instance)
{
InFallDamage = false;
}
}
[HarmonyPatch(typeof(CharacterGrabbing), "Reach")]
public static class Reach
{
public static Character character;
[HarmonyPrefix]
public static void Prefix(CharacterGrabbing __instance)
{
character = ((Component)__instance).GetComponent<Character>();
}
[HarmonyPostfix]
public static void Postfix()
{
character = null;
}
}
[HarmonyPatch(typeof(Character), "RPCA_PassOut")]
public static class RPCA_PassOut
{
[HarmonyPostfix]
public static void Prefix(Character __instance)
{
foreach (AscentGimmick gimmick in AscentGimmickHandler.gimmicks)
{
if (gimmick.active)
{
gimmick.CharacterPassedOut(__instance);
}
}
}
}
[HarmonyPatch(typeof(CharacterAfflictions), "UpdateNormalStatuses")]
public static class UpdateNormalStatuses
{
public static bool InUpdateNormalStatuses;
[HarmonyPrefix]
public static void Prefix(CharacterAfflictions __instance)
{
foreach (AscentGimmick gimmick in AscentGimmickHandler.gimmicks)
{
if (gimmick.active)
{
gimmick.OnUpdateNormalStatuses(__instance.character);
}
}
InUpdateNormalStatuses = true;
}
[HarmonyPostfix]
public static void Postfix()
{
InUpdateNormalStatuses = false;
}
}
[HarmonyPatch(typeof(CharacterAfflictions), "AddStatus")]
public static class AddStatus
{
[HarmonyPrefix]
public static void Prefix(CharacterAfflictions __instance, ref float amount, STATUSTYPE statusType)
{
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
float num = 1f;
foreach (AscentGimmick gimmick in AscentGimmickHandler.gimmicks)
{
if (gimmick.active)
{
num += gimmick.AfflictionMultiplier(__instance, statusType, amount);
}
}
amount *= num;
}
[HarmonyPostfix]
public static void Postfix(CharacterAfflictions __instance, bool __result, float amount, STATUSTYPE statusType)
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Invalid comparison between Unknown and I4
if (!__result || !CheckFallDamage.InFallDamage || (int)statusType != 0)
{
return;
}
foreach (AscentGimmick gimmick in AscentGimmickHandler.gimmicks)
{
if (gimmick.active)
{
gimmick.OnCharacterFall(__instance.character);
}
}
}
}
}
internal class DisableAscent7
{
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public static class Patch
{
[HarmonyPostfix]
public static void Postfix(ref bool __result)
{
if (Plugin.ascent13Disabler.Value)
{
__result = true;
}
}
}
}
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
public class FallDamageGimmick : AscentGimmick
{
public override string GetTitle()
{
return "Ascent 9";
}
public override string GetDescription()
{
return "Butter Fingers.";
}
public override void OnCharacterFall(Character character)
{
if (character.IsLocal)
{
((object)Character.localCharacter.refs.items).GetType().GetMethod("DropAllItems", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(Character.localCharacter.refs.items, new object[1] { true });
}
}
}
public class CampfireGimmick : AscentGimmick
{
public override string GetDescription()
{
return "Campfires are extremely hot.";
}
public override string GetTitle()
{
return "Chaos 2";
}
public override void OnFinishCooking(ItemCooking itemCooking)
{
itemCooking.wreckWhenCooked = true;
}
}
public class FogGimmick : AscentGimmick
{
public override string GetDescription()
{
return "The fog starts earlier and moves faster.";
}
public override string GetTitle()
{
return "Chaos 2";
}
public override void OnFogInitNewSphere(OrbFogHandler fog)
{
fog.currentStartForward = 0f;
fog.currentStartHeight = 0f;
fog.speed *= 2f;
fog.maxWaitTime /= 10f;
Plugin.Logger.LogWarning((object)"patched fog AGAIN");
}
}
public class FogPatches
{
[HarmonyPatch(typeof(OrbFogHandler), "InitNewSphere")]
public static class Start
{
[HarmonyPostfix]
public static void Postfix(OrbFogHandler __instance)
{
foreach (AscentGimmick gimmick in AscentGimmickHandler.gimmicks)
{
if (gimmick.active)
{
gimmick.OnFogInitNewSphere(__instance);
}
}
}
}
}
public class GUIManagerPatches
{
[HarmonyPatch(typeof(GUIManager), "Grasp")]
public static class Grasp
{
public static float SinceLastGrab;
[HarmonyPrefix]
public static void Prefix()
{
if (!CharacterPatches.Reach.character.IsLocal)
{
Plugin.Logger.LogWarning((object)"not local, not firing OnGrabbedCharacter to gimmicks.");
}
else
{
if (SinceLastGrab <= 1f)
{
return;
}
SinceLastGrab = 0f;
Plugin.Logger.LogInfo((object)"success");
foreach (AscentGimmick gimmick in AscentGimmickHandler.gimmicks)
{
if (gimmick.active)
{
gimmick.OnGrabbedCharacter(Character.localCharacter);
}
}
}
}
}
}
public class HelpingIsBadGimmick : AscentGimmick
{
public override string GetTitle()
{
return "Ascent 12";
}
public override string GetDescription()
{
return "Helping makes you drowsy.";
}
public override void OnGrabbedCharacter(Character character)
{
character.refs.afflictions.AddStatus((STATUSTYPE)6, 0.05f, false, true, true);
}
}
public class ItemCookingPatches
{
[HarmonyPatch(typeof(ItemCooking), "FinishCookingRPC")]
public static class FinishCookingRPC
{
[HarmonyPrefix]
public static void Prefix(ItemCooking __instance)
{
foreach (AscentGimmick gimmick in AscentGimmickHandler.gimmicks)
{
if (gimmick.active)
{
gimmick.OnFinishCooking(__instance);
}
}
}
}
}
public class LavaRiverPatches
{
[HarmonyPatch(typeof(Lava), "Start")]
public static class Start
{
[HarmonyPrefix]
public static void Prefix(Lava __instance)
{
foreach (AscentGimmick gimmick in AscentGimmickHandler.gimmicks)
{
if (gimmick.active)
{
gimmick.OnLavaExisted(__instance);
}
}
}
}
}
public class OccultStatueGimmick : AscentGimmick
{
private List<Spawner> despawnQueue;
private readonly object despawnQueue_lockObj = new object();
public override string GetTitle()
{
return "Ascent 13";
}
public override string GetDescription()
{
return "No more Revive Statues.";
}
public override void RespawnChestExisted(Spawner chest)
{
if (Plugin.ascent13Disabler.Value)
{
return;
}
object obj = despawnQueue_lockObj;
lock (obj)
{
if (despawnQueue == null)
{
despawnQueue = new List<Spawner>();
((MonoBehaviour)Plugin.Instance).StartCoroutine(DespawnStatusDelayed());
}
despawnQueue.Add(chest);
}
}
private IEnumerator DespawnStatusDelayed()
{
yield return (object)new WaitForSeconds(1f);
lock (despawnQueue_lockObj)
{
if (despawnQueue == null)
{
yield break;
}
foreach (Spawner chest in despawnQueue)
{
if ((Object)(object)chest != (Object)null)
{
Object.Destroy((Object)(object)((Component)chest).gameObject);
}
}
despawnQueue.Clear();
despawnQueue = null;
}
}
}
[BepInPlugin("MoreAscents", "MoreAscents", "1.0.0")]
internal class Plugin : BaseUnityPlugin
{
internal static ManualLogSource Logger;
internal static Plugin Instance;
internal static ConfigEntry<int> ascentsUnlocked;
internal static ConfigEntry<bool> ascent13Disabler;
private static bool Initted;
private void Awake()
{
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
Logger = ((BaseUnityPlugin)this).Logger;
Instance = this;
ascentsUnlocked = ((BaseUnityPlugin)this).Config.Bind<int>("General", "MaxAscent", 0, "");
ascent13Disabler = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Ascent 13 Disabler", false, "Disables ascent 13.");
AscentGimmickHandler.GetBaseAscentCount();
AscentGimmickHandler.RegisterAscent<FallDamageGimmick>();
AscentGimmickHandler.RegisterAscent<AfflictionGimmick>();
AscentGimmickHandler.RegisterAscent<TheNightIsColderGimmick>();
AscentGimmickHandler.RegisterAscent<HelpingIsBadGimmick>();
AscentGimmickHandler.RegisterAscent<OccultStatueGimmick>();
AscentGimmickHandler.RegisterAscent<SkeletonGimmick>();
AscentGimmickHandler.RegisterAscent<CampfireGimmick>();
AscentGimmickHandler.RegisterAscent<SunHotGimmick>();
AscentGimmickHandler.RegisterAscent<BingBongGimmick>();
AscentGimmickHandler.Initialize();
Logger.LogInfo((object)"Plugin MoreAscents is loaded!");
new Harmony("MoreAscents").PatchAll();
}
internal static void Init()
{
if (Initted)
{
return;
}
Initted = true;
int num = default(int);
if (Singleton<AchievementManager>.Instance.GetSteamStatInt((STEAMSTATTYPE)13, ref num))
{
if (num > AscentGimmickHandler.BaseAscents)
{
Singleton<AchievementManager>.Instance.SetSteamStat((STEAMSTATTYPE)13, AscentGimmickHandler.BaseAscents);
}
ascentsUnlocked.Value = ((ascentsUnlocked.Value < num) ? num : ascentsUnlocked.Value);
}
Logger.LogInfo((object)"Initted");
}
private void Update()
{
GUIManagerPatches.Grasp.SinceLastGrab += Time.deltaTime;
foreach (AscentGimmick gimmick in AscentGimmickHandler.gimmicks)
{
if (gimmick.active)
{
gimmick.Update();
}
}
}
}
public class RopeSpoolPatches
{
[HarmonyPatch(typeof(RopeSpool), "OnInstanceDataSet")]
public static class OnInstanceDataSet
{
[HarmonyPrefix]
public static void Prefix(RopeSpool __instance)
{
}
}
}
public class SkeletonGimmick : AscentGimmick
{
public override string GetDescription()
{
return "Passing out instantly turns you into a skeleton.";
}
public override string GetTitle()
{
return "Chaos 1";
}
public override void CharacterPassedOut(Character character)
{
if (character.IsLocal)
{
((object)character).GetType().GetMethod("DieInstantly", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(character, Array.Empty<object>());
}
}
}
public class SpawnerPatches
{
[HarmonyPatch(typeof(Spawner), "SpawnItems")]
public static class GetSpawnSpots
{
[HarmonyPrefix]
public static void Prefix(Spawner __instance, ref List<Transform> spawnSpots)
{
foreach (AscentGimmick gimmick in AscentGimmickHandler.gimmicks)
{
if (gimmick.active)
{
gimmick.SpawnerSpawnItems(__instance, ref spawnSpots);
}
}
}
}
[HarmonyPatch(typeof(Luggage), "Awake")]
public static class Awake
{
[HarmonyPostfix]
public static void Postfix(Luggage __instance)
{
if (((object)__instance).GetType() != typeof(RespawnChest))
{
return;
}
foreach (AscentGimmick gimmick in AscentGimmickHandler.gimmicks)
{
if (gimmick.active)
{
gimmick.RespawnChestExisted((Spawner)(object)__instance);
}
}
}
}
}
public class SunHotGimmick : AscentGimmick
{
public override string GetDescription()
{
return "The sun is very hot, don't get heatstroke.";
}
public override string GetTitle()
{
return "Chaos 3";
}
public override void OnUpdateNormalStatuses(Character character)
{
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
if (!character.IsLocal || DayNightManager.instance.isDay < 0.5f)
{
return;
}
MountainProgressHandler instance = Singleton<MountainProgressHandler>.Instance;
if (!((Object)(object)instance == (Object)null) && instance.maxProgressPointReached < 3)
{
Vector3 val = -((Component)RenderSettings.sun).transform.forward;
RaycastHit val2 = HelperFunctions.LineCheck(character.Center, character.Center + val * 1000f, (LayerType)5, 0f, (QueryTriggerInteraction)1);
if (!Object.op_Implicit((Object)(object)((RaycastHit)(ref val2)).transform) || !(((Object)((Component)((RaycastHit)(ref val2)).transform).gameObject).name != "EdgeWall"))
{
character.refs.afflictions.AddStatus((STATUSTYPE)8, 0.0025f * Time.deltaTime, false, true, true);
}
}
}
}
public class TheNightIsColderGimmick : AscentGimmick
{
public override string GetTitle()
{
return "Ascent 11";
}
public override string GetDescription()
{
return "The night now is colder than the normal one.";
}
public override float AfflictionMultiplier(CharacterAfflictions affliction, STATUSTYPE statusType, float amount)
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Invalid comparison between Unknown and I4
if (!affliction.character.IsLocal)
{
return 0f;
}
if ((int)statusType == 2)
{
return 2f;
}
return 0f;
}
}
