using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
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 Microsoft.CodeAnalysis;
using MoreAscents.API;
using MoreAscents.Patches;
using UnityEngine;
using Zorro.Core;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.1", FrameworkDisplayName = ".NET Framework 4.7.1")]
[assembly: AssemblyCompany("MoreAscents")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+f6908f24683ec918c855d54dd37fb310f0efbb27")]
[assembly: AssemblyProduct("MoreAscents")]
[assembly: AssemblyTitle("MoreAscents")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.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 MoreAscents
{
public class AscentGimmick
{
public AscentStruct _ascentData;
public bool active;
public virtual string GetTitle()
{
return "";
}
public virtual string GetDescription()
{
return "";
}
public virtual Color GetColor()
{
//IL_0000: 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_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: 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_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Expected O, but got Unknown
AscentGimmick ascentGimmick = Activator.CreateInstance<T>();
AscentInstanceData val2 = 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 = val2,
order = 9 + (gimmicks.Count + 1)
};
gimmicks.Add(ascentGimmick);
if (HasInitialized)
{
HotLoadAscentInstanceData(SingletonAsset<AscentData>.Instance.ascents, val2);
Plugin.Logger.LogInfo((object)("Hot loaded " + val2.title + "!"));
return;
}
pendingDatas.Add(val2);
Plugin.Logger.LogInfo((object)("Queued " + val2.title));
_ = ascentGimmick._ascentData;
AddIdentityTranslation(ascentGimmick.GetTitle(), ascentGimmick.GetTitle());
AddIdentityTranslation("desc_" + ascentGimmick.GetTitle(), ascentGimmick.GetDescription());
static void AddIdentityTranslation(string key, string val)
{
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 AfflictionGimmick : AscentGimmick
{
public override string GetTitle()
{
return "Ascent 9";
}
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_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: Invalid comparison between Unknown and I4
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Invalid comparison between Unknown and I4
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Invalid comparison between Unknown and I4
if ((int)statusType == 0 || (int)statusType == 1 || (int)statusType == 7 || !affliction.character.IsLocal || (CharacterPatches.UpdateNormalStatuses.InUpdateNormalStatuses && (int)statusType == 2))
{
return 0f;
}
return 2f;
}
}
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_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: 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);
break;
}
}
}
}
}
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 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 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_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: 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)
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: 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)
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);
}
}
}
}
public class FallDamageGimmick : AscentGimmick
{
public override string GetTitle()
{
return "Ascent 8";
}
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 HelpingIsBadGimmick : AscentGimmick
{
public override string GetTitle()
{
return "Ascent 11";
}
public override string GetDescription()
{
return "Helping makes you drowsy.";
}
public override void OnGrabbedCharacter(Character character)
{
character.refs.afflictions.AddStatus((STATUSTYPE)6, 0.05f, false);
}
}
public class LuggageGimmick : AscentGimmick
{
public override string GetTitle()
{
return "Ascent 10";
}
public override string GetDescription()
{
return "Big Luggage's have a chance to only contain one item.";
}
public override void SpawnerSpawnItems(Spawner spawner, ref List<Transform> spawnSpots)
{
if (((Object)((Component)spawner).gameObject).name == "LuggageBig" && Random.Range(0, 2) == 0)
{
List<Transform> list = new List<Transform>();
list.Add(spawnSpots[0]);
spawnSpots = list;
}
}
}
public class OccultStatueGimmick : AscentGimmick
{
public override string GetTitle()
{
return "Ascent 12";
}
public override string GetDescription()
{
return "No more Revive Statues.";
}
public override void RespawnChestExisted(Spawner chest)
{
if (!Plugin.ascent7Disabler.Value)
{
((Component)chest).gameObject.SetActive(false);
}
}
}
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");
}
}
[BepInPlugin("MoreAscents", "MoreAscents", "1.0.0")]
internal class Plugin : BaseUnityPlugin
{
internal static ManualLogSource Logger;
internal static ConfigEntry<int> ascentsUnlocked;
internal static ConfigEntry<bool> ascent7Disabler;
private static bool Initted;
private void Awake()
{
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
Logger = ((BaseUnityPlugin)this).Logger;
ascentsUnlocked = ((BaseUnityPlugin)this).Config.Bind<int>("General", "MaxAscent", 0, "");
ascent7Disabler = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Ascent 7/12 Disabler", false, "Disables ascent 7 and 12.");
AscentGimmickHandler.GetBaseAscentCount();
AscentGimmickHandler.RegisterAscent<FallDamageGimmick>();
AscentGimmickHandler.RegisterAscent<AfflictionGimmick>();
AscentGimmickHandler.RegisterAscent<LuggageGimmick>();
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();
}
}
}
}
[HarmonyPatch(typeof(BoardingPass), "UpdateAscent")]
internal static class boarding_initilize_patch
{
internal static void Prefix(BoardingPass __instance)
{
if (Input.GetKey((KeyCode)108))
{
Singleton<AchievementManager>.Instance.SetSteamStat((STEAMSTATTYPE)13, 155);
}
FieldInfo field = ((object)__instance).GetType().GetField("maxAscent", BindingFlags.Instance | BindingFlags.NonPublic);
field.SetValue(__instance, SingletonAsset<AscentData>.Instance.ascents.Count - 2);
Plugin.Logger.LogInfo((object)$"Ascents capped {field.GetValue(__instance)}");
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "MoreAscents";
public const string PLUGIN_NAME = "MoreAscents";
public const string PLUGIN_VERSION = "1.0.0";
}
}
namespace MoreAscents.Patches
{
public class AirportCheckInKioskPatches
{
[HarmonyPatch(typeof(AirportCheckInKiosk), "BeginIslandLoadRPC")]
public static class LoadIslandMaster
{
[HarmonyPrefix]
public static void Prefix(int ascent)
{
_ = GUIManager.instance.boardingPass.ascentData.ascents[ascent + 1];
AscentGimmickHandler.DisableGimmicks();
AscentGimmickHandler.MarkGimmicksAsActive(ascent + 1);
}
}
}
internal class BingBongPatches
{
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
internal static class Patch
{
[HarmonyPrefix]
internal static void Prefix(Item value)
{
if ((Object)(object)value != (Object)null && value != null && (value.UIData?.itemName?.ToLowerInvariant()?.Equals("bing bong")).GetValueOrDefault())
{
heldBingBongItem = value;
}
else
{
heldBingBongItem = null;
}
}
}
internal static Item heldBingBongItem;
}
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_0026: 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_000b: Unknown result type (might be due to invalid IL or missing references)
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.ascent7Disabler.Value)
{
__result = true;
}
}
}
}
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")]
internal static class SetSteamStat
{
[HarmonyPrefix]
internal static void Prefix(STEAMSTATTYPE steamStatType, ref int value)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Invalid comparison between Unknown and I4
if ((int)steamStatType == 13)
{
Plugin.ascentsUnlocked.Value = value;
if (value > AscentGimmickHandler.BaseAscents - 1)
{
value = AscentGimmickHandler.BaseAscents - 1;
}
}
}
}
}
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 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 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 RopeSpoolPatches
{
[HarmonyPatch(typeof(RopeSpool), "OnInstanceDataSet")]
public static class OnInstanceDataSet
{
[HarmonyPrefix]
public static void Prefix(RopeSpool __instance)
{
}
}
}
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);
}
}
}
}
}
}
namespace MoreAscents.API
{
internal class BingBongMechanics
{
internal static float BingBongUnheldFor;
}
}
