using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem.Collections.Generic;
using Microsoft.CodeAnalysis;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("SoDQuickRest")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.11.1.0")]
[assembly: AssemblyInformationalVersion("0.11.1")]
[assembly: AssemblyProduct("SoDQuickRest")]
[assembly: AssemblyTitle("SoDQuickRest")]
[assembly: AssemblyVersion("0.11.1.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[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]
[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;
}
}
[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 SoDQuickRest
{
[BepInPlugin("sm3gm.sod.skiptimeanywhere", "Skip Time Anywhere", "1.0.0")]
public sealed class Plugin : BasePlugin
{
public const string VER = "1.0.0";
internal static ManualLogSource L;
internal static ConfigEntry<float> Speed;
internal static ConfigEntry<float> SkipSpeed;
internal static ConfigEntry<bool> BoostGameRest;
internal static ConfigEntry<string> WatchKey;
internal static ConfigEntry<string> FullSkipKey;
internal static ConfigEntry<string> EarlierKey;
internal static ConfigEntry<string> LaterKey;
internal static ConfigEntry<bool> WakeOnPhone;
internal static ConfigEntry<bool> WakeOnKnock;
internal static ConfigEntry<bool> WakeOnMurder;
internal static ConfigEntry<bool> WakeOnBodyFound;
internal static ConfigEntry<float> WakeWhenColder;
internal static ConfigEntry<float> WakeWhenHurt;
internal static ConfigEntry<bool> ShowWatchHint;
internal static ConfigEntry<bool> StandingMenu;
internal static ConfigEntry<float> StandingMenuDelay;
internal static ConfigEntry<bool> ReplaceHoursToggle;
internal static ConfigEntry<string> PadAlarm;
internal static ConfigEntry<string> PadHour;
internal static ConfigEntry<string> PromptAlarmSlot;
internal static ConfigEntry<string> PromptHourSlot;
public override void Load()
{
//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
//IL_0309: Unknown result type (might be due to invalid IL or missing references)
//IL_0319: Unknown result type (might be due to invalid IL or missing references)
//IL_0349: Unknown result type (might be due to invalid IL or missing references)
//IL_034f: Expected O, but got Unknown
L = ((BasePlugin)this).Log;
Speed = ((BasePlugin)this).Config.Bind<float>("Speed", "RestSpeed", 80f, "How many times faster than normal the clock runs while you wait or sleep. The game's own speed is 40.");
SkipSpeed = ((BasePlugin)this).Config.Bind<float>("Speed", "SkipSpeed", 2000f, "Speed for Ctrl+Shift+Alt+R, the near-instant skip. The world still runs, just very fast, so wake-ups still work.");
BoostGameRest = ((BasePlugin)this).Config.Bind<bool>("Speed", "BoostGameRest", true, "Also speed up the game's own sleeping and waiting in beds and chairs. Turn off if another mod already changes that.");
WatchKey = ((BasePlugin)this).Config.Bind<string>("Keys", "SkipHourKey", "T", "With the watch held up, or while sitting or lying down to pass time: skip one hour. Unity key name, empty = off.");
FullSkipKey = ((BasePlugin)this).Config.Bind<string>("Keys", "SkipToWatchTimeKey", "Y", "Skip straight to the time set on the watch. Unity key name, empty = off.");
EarlierKey = ((BasePlugin)this).Config.Bind<string>("Keys", "WatchEarlierKey", "Comma", "With the watch held up: set the watch time 15 minutes earlier. Unity key name.");
LaterKey = ((BasePlugin)this).Config.Bind<string>("Keys", "WatchLaterKey", "Period", "With the watch held up: set the watch time 15 minutes later. Unity key name.");
WakeOnPhone = ((BasePlugin)this).Config.Bind<bool>("Wake", "PhoneRings", true, "Wake when a phone rings where you are.");
WakeOnKnock = ((BasePlugin)this).Config.Bind<bool>("Wake", "DoorKnock", true, "Wake when someone knocks on a door near you.");
WakeOnMurder = ((BasePlugin)this).Config.Bind<bool>("Wake", "Murder", true, "Wake when a murder happens.");
WakeOnBodyFound = ((BasePlugin)this).Config.Bind<bool>("Wake", "BodyFound", true, "Wake when a body is found.");
PromptAlarmSlot = ((BasePlugin)this).Config.Bind<string>("Prompts", "AlarmPromptButton", "crouch", "Game button slot for the Skip To Alarm prompt while time passes (game names such as flashlight, crouch, alternative). The prompt shows the real key or controller button. Empty = the alarm menu's own button.");
PromptHourSlot = ((BasePlugin)this).Config.Bind<string>("Prompts", "HourPromptButton", "", "Game button slot for the Skip One Hour prompt while time passes. Empty = the alarm menu's own button.");
PadAlarm = ((BasePlugin)this).Config.Bind<string>("Controller", "SkipToAlarmPadButton", "JoystickButton1", "Controller button that skips to the alarm while time passes (JoystickButton1 = B on an Xbox pad, the button the prompt shows). Empty = off.");
PadHour = ((BasePlugin)this).Config.Bind<string>("Controller", "SkipHourButton", "", "Controller button that skips one hour while time passes (JoystickButton2 = X on an Xbox pad). Empty = off.");
ReplaceHoursToggle = ((BasePlugin)this).Config.Bind<bool>("Watch", "SkipToAlarmPrompt", true, "In the pass-time menu (standing, chairs, beds), the Switch Hours/Minutes prompt becomes Skip To Alarm. Alarm Forward/Back still step the alarm.");
StandingMenu = ((BasePlugin)this).Config.Bind<bool>("Watch", "StandingMenu", true, "Look at your watch and hold still to get the game's own pass-time menu while standing.");
StandingMenuDelay = ((BasePlugin)this).Config.Bind<float>("Watch", "StandingMenuDelay", 1.5f, "Seconds of holding still with the watch raised before the menu opens.");
ShowWatchHint = ((BasePlugin)this).Config.Bind<bool>("Keys", "ShowWatchHint", true, "Show the pass time keys each time you raise the watch.");
WakeWhenColder = ((BasePlugin)this).Config.Bind<float>("Wake", "ColdBelow", 0.15f, "Wake when your warmth drops to this or lower (0 = freezing, 1 = warm) and is still dropping, so you do not freeze to death outside. Warming up somewhere warm never wakes you. 0 = off.");
WakeWhenHurt = ((BasePlugin)this).Config.Bind<float>("Wake", "HealthBelow", 0.5f, "Wake when your health drops to this share of the maximum or lower. 0 = off.");
Harmony val = new Harmony("sm3gm.sod.skiptimeanywhere");
val.PatchAll(typeof(PromptText));
val.PatchAll(typeof(Patches));
val.PatchAll(typeof(StandMenuPatches));
val.PatchAll(typeof(SkipPromptPatches));
val.PatchAll(typeof(SkipButtonPatches));
((BasePlugin)this).AddComponent<Keeper>();
ManualLogSource l = L;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(26, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Skip Time Anywhere ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("1.0.0");
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" loaded");
}
l.LogInfo(val2);
}
}
internal static class Rest
{
internal static Interactable? Spot;
internal static bool Own;
internal static float HoursLeft;
internal static float OwnSpeed;
internal static float LastClock = -1f;
private static float lastSkipPress = -1f;
internal static bool GameResting
{
get
{
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Invalid comparison between Unknown and I4
try
{
return (Object)(object)Player.Instance != (Object)null && Player.Instance.spendingTimeMode && (int)SessionData.Instance.currentTimeSpeed == 3;
}
catch
{
return false;
}
}
}
internal static bool Resting
{
get
{
if (!Own)
{
return GameResting;
}
return true;
}
}
internal static float Clock => SessionData.Instance.decimalClock;
internal static void StartOrExtend(bool skip)
{
if (!Own)
{
Own = true;
HoursLeft = 0f;
LastClock = Clock;
try
{
SessionData.Instance.SetTimeSpeed((TimeSpeed)3);
}
catch
{
}
}
HoursLeft = Math.Min(HoursLeft + 1f, 24f);
OwnSpeed = (skip ? Plugin.SkipSpeed.Value : Plugin.Speed.Value);
Note((skip ? "Skipping" : "Waiting") + " until " + Fmt(Clock + HoursLeft) + ". Press again for another hour, Esc or move to stop.");
}
internal static float AlarmHoursAhead()
{
try
{
float alarm = Player.Instance.alarm;
float clock = Clock;
if (alarm <= 0f)
{
return -1f;
}
float num = alarm % 24f - clock;
if (num < 0f)
{
num += 24f;
}
return num;
}
catch
{
return -1f;
}
}
internal static void Skip(float hours, string what)
{
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Expected O, but got Unknown
if (!Own)
{
Own = true;
LastClock = Clock;
try
{
SessionData.Instance.SetTimeSpeed((TimeSpeed)3);
}
catch
{
}
HoursLeft = 0f;
}
HoursLeft = Math.Min(HoursLeft + hours, 24f);
OwnSpeed = Plugin.SkipSpeed.Value;
ManualLogSource l = Plugin.L;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(25, 3, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[REST] skip ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(hours, "0.00");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" h (");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(what);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("), until ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(Fmt(Clock + HoursLeft));
}
l.LogInfo(val);
Note("Skipping to " + Fmt(Clock + HoursLeft) + ".");
}
internal static void StopOwn(string why)
{
if (Own)
{
Own = false;
try
{
SessionData.Instance.SetTimeSpeed((TimeSpeed)1);
}
catch
{
}
if (why.Length > 0)
{
Note(why);
}
}
}
internal static void Wake(string why)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Expected O, but got Unknown
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_0083: Invalid comparison between Unknown and I4
if (!Resting)
{
return;
}
ManualLogSource l = Plugin.L;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(15, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[REST] waking: ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(why);
}
l.LogInfo(val);
bool own = Own;
if (own)
{
StopOwn("");
}
try
{
if (Spot != null && Player.Instance.spendingTimeMode)
{
ActionController.Instance.CancelPassTime(Spot, Spot.node, (Actor)(object)Player.Instance);
}
if ((int)SessionData.Instance.currentTimeSpeed != 1)
{
SessionData.Instance.SetTimeSpeed((TimeSpeed)1);
}
}
catch (Exception ex)
{
Plugin.L.LogWarning((object)("[REST] wake failed: " + ex.Message));
}
if (StandMenu.Active)
{
StandMenu.Close();
}
Note((own ? "You stopped waiting: " : "You woke up: ") + why);
}
internal static string Fmt(float h)
{
h %= 24f;
int num = (int)h;
int value = (int)((h - (float)num) * 60f);
return $"{num:00}:{value:00}";
}
internal static bool Debounce()
{
if (Time.unscaledTime - lastSkipPress < 0.3f)
{
return false;
}
lastSkipPress = Time.unscaledTime;
return true;
}
internal static void Note(string msg)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
try
{
InterfaceController.Instance.NewGameMessage((GameMessageType)0, 0, msg, (Icon)3, (AudioEvent)null, false, default(Color), -1, 0f, (RectTransform)null, (PingOnComplete)0, (Evidence)null, (List<DataKey>)null, (Sprite)null);
}
catch
{
}
}
}
[HarmonyPatch]
internal static class Patches
{
[HarmonyPatch(typeof(ActionController), "PassTime")]
[HarmonyPrefix]
private static void PassTime(Interactable what)
{
Rest.Spot = what;
}
[HarmonyPatch(typeof(SessionData), "SetTimeSpeed")]
[HarmonyPostfix]
private static void SpeedSet()
{
Keeper.Apply();
}
[HarmonyPatch(typeof(TelephoneController), "AddActiveCall")]
[HarmonyPostfix]
private static void Call(PhoneCall newCall)
{
if (!Plugin.WakeOnPhone.Value || !Rest.Resting)
{
return;
}
try
{
NewGameLocation currentGameLocation = ((Actor)Player.Instance).currentGameLocation;
if (((newCall != null) ? newCall.toNS : null) != null && (Object)(object)currentGameLocation != (Object)null && (Object)(object)newCall.toNS.location == (Object)(object)currentGameLocation)
{
Rest.Wake("the phone is ringing");
}
}
catch
{
}
}
[HarmonyPatch(typeof(NewDoor), "OnKnock")]
[HarmonyPostfix]
private static void Knock(NewDoor __instance)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
if (!Plugin.WakeOnKnock.Value || !Rest.Resting)
{
return;
}
try
{
if (Vector3.Distance(((Component)__instance).transform.position, ((Component)Player.Instance).transform.position) < 15f)
{
Rest.Wake("someone is knocking");
}
}
catch
{
}
}
[HarmonyPatch(typeof(MurderController), "OnVictimKilled")]
[HarmonyPostfix]
private static void Killed()
{
if (Plugin.WakeOnMurder.Value)
{
Rest.Wake("there has been a murder");
}
}
[HarmonyPatch(typeof(MurderController), "OnVictimDiscovery")]
[HarmonyPostfix]
private static void Found()
{
if (Plugin.WakeOnBodyFound.Value)
{
Rest.Wake("a body has been found");
}
}
}
public class Keeper : MonoBehaviour
{
private static KeyCode? hourKey;
private static KeyCode? fullKey;
private static KeyCode? earlier;
private static KeyCode? later;
private static KeyCode? padAlarm;
private static KeyCode? padHour;
private static bool wasRunning;
private static bool watchShown;
private float nextBody;
private float lastHeat = -1f;
private float lowestHeat = 2f;
public Keeper(IntPtr ptr)
: base(ptr)
{
}
internal static void Apply()
{
try
{
float num = (Rest.Own ? Rest.OwnSpeed : ((Plugin.BoostGameRest.Value && Rest.GameResting) ? Plugin.Speed.Value : 0f));
if (num > 0f && SessionData.Instance.currentTimeMultiplier < num)
{
SessionData.Instance.currentTimeMultiplier = num;
}
}
catch
{
}
}
private static string Or(string text, string pad)
{
if (!string.IsNullOrWhiteSpace(pad))
{
return text + " or " + PadName(pad);
}
return text;
}
private static string PadName(string key)
{
return key switch
{
"JoystickButton0" => "A",
"JoystickButton1" => "B",
"JoystickButton2" => "X",
"JoystickButton3" => "Y",
"JoystickButton4" => "LB",
"JoystickButton5" => "RB",
"JoystickButton6" => "Back",
"JoystickButton7" => "Start",
"JoystickButton8" => "left stick",
"JoystickButton9" => "right stick",
_ => key,
};
}
private static bool KeyDown(ref KeyCode? cache, ConfigEntry<string> entry)
{
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: 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)
if (!cache.HasValue)
{
string text = entry.Value?.Trim() ?? "";
cache = (KeyCode)((text.Length > 0 && Enum.TryParse<KeyCode>(text, ignoreCase: true, out KeyCode result)) ? ((int)result) : 0);
}
if (cache != (KeyCode?)0)
{
return Input.GetKeyDown(cache.Value);
}
return false;
}
private static string Pretty(string key)
{
if (!(key == "Comma"))
{
if (key == "Period")
{
return ".";
}
return key;
}
return ",";
}
private static bool HoldingWatch()
{
try
{
FirstPersonItemController instance = FirstPersonItemController.Instance;
object obj;
if (instance == null)
{
obj = null;
}
else
{
FirstPersonItem currentItem = instance.currentItem;
obj = ((currentItem != null) ? ((Object)currentItem).name : null);
}
if (obj == null)
{
obj = "";
}
return ((string)obj).IndexOf("watch", StringComparison.OrdinalIgnoreCase) >= 0;
}
catch
{
return false;
}
}
private void Update()
{
//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
//IL_0146: Unknown result type (might be due to invalid IL or missing references)
//IL_014d: Expected O, but got Unknown
//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
//IL_03c1: Expected O, but got Unknown
//IL_04f6: Unknown result type (might be due to invalid IL or missing references)
//IL_04fc: Invalid comparison between Unknown and I4
bool flag = Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305);
bool flag2 = Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303);
bool skip = Input.GetKey((KeyCode)308) || Input.GetKey((KeyCode)307);
try
{
bool flag3 = HoldingWatch();
StandMenu.Tick(flag3);
if (flag3 && !watchShown && Plugin.ShowWatchHint.Value)
{
Rest.Note("Hold still to pass time.");
}
watchShown = flag3;
bool flag4 = false;
try
{
flag4 = (Object)(object)Player.Instance != (Object)null && (Player.Instance.spendingTimeMode || Player.Instance.setAlarmMode);
}
catch
{
}
bool flag5 = default(bool);
if (flag3 && !flag && (KeyDown(ref earlier, Plugin.EarlierKey) || KeyDown(ref later, Plugin.LaterKey)))
{
Player instance = Player.Instance;
bool keyDown = Input.GetKeyDown(later.GetValueOrDefault());
if (!instance.setAlarmMode)
{
instance.SetSettingAlarmMode(true);
if (Rest.AlarmHoursAhead() < 0.25f)
{
instance.alarm = Rest.Clock;
}
}
instance.AddToAlarmTime(keyDown ? 0.25f : (-0.25f));
ManualLogSource l = Plugin.L;
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(36, 2, ref flag5);
if (flag5)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[REST] watch set to ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(instance.alarm, "0.00");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" (setAlarmMode=");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<bool>(instance.setAlarmMode);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(")");
}
l.LogInfo(val);
Rest.Note($"Watch set to {Rest.Fmt(instance.alarm)}. {Plugin.FullSkipKey.Value} to skip there, {Plugin.WatchKey.Value} for one hour.");
}
if ((flag3 || flag4) && !flag && KeyDown(ref hourKey, Plugin.WatchKey))
{
Rest.LastClock = Rest.Clock;
Rest.Skip(1f, "one hour");
}
if ((flag3 || flag4) && !flag && KeyDown(ref fullKey, Plugin.FullSkipKey))
{
float num = Rest.AlarmHoursAhead();
if (num <= 0.01f)
{
Rest.Note("Set a time on the watch first.");
}
else
{
Rest.LastClock = Rest.Clock;
Rest.Skip(num, "the watch time");
}
}
bool flag6 = false;
try
{
flag6 = (Object)(object)Player.Instance != (Object)null && Player.Instance.spendingTimeMode && !Player.Instance.setAlarmMode;
}
catch
{
}
if (flag6 && !wasRunning && Plugin.ShowWatchHint.Value)
{
Rest.Note(Or("Skip to alarm: R", Plugin.PadAlarm.Value) + ". " + Or("One hour: " + Plugin.WatchKey.Value, Plugin.PadHour.Value) + ".");
}
wasRunning = flag6;
if (flag6 && KeyDown(ref padHour, Plugin.PadHour) && Rest.Debounce())
{
Rest.LastClock = Rest.Clock;
Rest.Skip(1f, "one hour");
}
if (!flag && Plugin.ReplaceHoursToggle.Value && (Input.GetKeyDown((KeyCode)114) || (flag6 && KeyDown(ref padAlarm, Plugin.PadAlarm))) && Rest.Debounce() && flag6)
{
float num2 = Rest.AlarmHoursAhead();
ManualLogSource l2 = Plugin.L;
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(52, 1, ref flag5);
if (flag5)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[REST] Skip To Alarm pressed while resting, ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(num2, "0.00");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" h ahead");
}
l2.LogInfo(val);
if (num2 <= 0.01f)
{
Rest.Note("Set the alarm on your watch first.");
}
else
{
Rest.LastClock = Rest.Clock;
Rest.Skip(num2, "the alarm");
}
}
if (flag && flag2 && Input.GetKeyDown((KeyCode)114) && (Object)(object)SessionData.Instance != (Object)null && (Object)(object)Player.Instance != (Object)null)
{
if (!Rest.Own)
{
Rest.LastClock = Rest.Clock;
}
Rest.StartOrExtend(skip);
}
if (Rest.Own)
{
if (Input.GetKeyDown((KeyCode)27) || Input.GetKeyDown((KeyCode)119) || Input.GetKeyDown((KeyCode)97) || Input.GetKeyDown((KeyCode)115) || Input.GetKeyDown((KeyCode)100))
{
Rest.StopOwn("You stopped waiting.");
}
else
{
float clock = Rest.Clock;
Rest.HoursLeft -= ((clock >= Rest.LastClock) ? (clock - Rest.LastClock) : (clock + 24f - Rest.LastClock));
Rest.LastClock = clock;
if (Rest.HoursLeft <= 0f)
{
Rest.StopOwn("Done waiting.");
}
else if ((int)SessionData.Instance.currentTimeSpeed != 3)
{
SessionData.Instance.SetTimeSpeed((TimeSpeed)3);
}
}
}
}
catch
{
}
BodyCheck();
Apply();
}
private void BodyCheck()
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Expected O, but got Unknown
if (!Rest.Resting)
{
if (lowestHeat < 2f)
{
ManualLogSource l = Plugin.L;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(59, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[REST] rest over: lowest warmth ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(lowestHeat, "0.00");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" (wakes at ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(Plugin.WakeWhenColder.Value, "0.00");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" while dropping)");
}
l.LogInfo(val);
}
lowestHeat = 2f;
lastHeat = -1f;
}
else
{
if (Time.unscaledTime < nextBody)
{
return;
}
nextBody = Time.unscaledTime + 0.25f;
try
{
Player instance = Player.Instance;
float heat = ((Human)instance).heat;
bool flag2 = lastHeat >= 0f && heat < lastHeat - 0.0001f;
lastHeat = heat;
if (heat < lowestHeat)
{
lowestHeat = heat;
}
if (Plugin.WakeWhenColder.Value > 0f && heat <= Plugin.WakeWhenColder.Value && flag2)
{
Rest.Wake("you are getting cold");
}
else if (Plugin.WakeWhenHurt.Value > 0f && ((Actor)instance).maximumHealth > 0f && ((Actor)instance).currentHealth / ((Actor)instance).maximumHealth <= Plugin.WakeWhenHurt.Value)
{
Rest.Wake("you are hurt");
}
}
catch
{
}
}
}
}
internal static class StandMenu
{
internal static bool Active;
private static float stillSince = -1f;
private static Vector3 lastPos;
internal static Interactable? Spot;
private static GameObject? spotObject;
private static Vector3 standPos;
private static Quaternion standRot;
internal static float HoldUntil;
internal static float GuardUntil;
private static Vector3 guardPos;
private static bool loggedMove;
private static InteractablePreset? chairPreset;
internal static bool InGuard => Time.unscaledTime < GuardUntil;
internal static void Tick(bool watch)
{
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: 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_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_0297: Unknown result type (might be due to invalid IL or missing references)
//IL_029c: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Expected O, but got Unknown
//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
//IL_013f: Unknown result type (might be due to invalid IL or missing references)
//IL_0146: Expected O, but got Unknown
//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
//IL_01fa: Expected O, but got Unknown
if (!Plugin.StandingMenu.Value)
{
return;
}
Player instance = Player.Instance;
if ((Object)(object)instance == (Object)null)
{
return;
}
bool flag = default(bool);
if (!Active && Time.unscaledTime < GuardUntil)
{
Vector3 position = ((Component)instance).transform.position;
float num = Vector3.Distance(position, guardPos);
if (num > 3f)
{
ManualLogSource l = Plugin.L;
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(47, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[REST] moved ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(num, "0.0");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" m in one step after resting (to ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Vector3>(position);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(")");
}
l.LogInfo(val);
}
guardPos = position;
}
if (Time.unscaledTime < HoldUntil)
{
return;
}
if (Active)
{
Interactable lockedInInteraction = InteractionController.Instance.lockedInInteraction;
bool num2 = lockedInInteraction != null && Spot != null && ((Il2CppObjectBase)lockedInInteraction).Pointer == ((Il2CppObjectBase)Spot).Pointer;
bool flag2 = instance.spendingTimeMode && Spot != null && Rest.Spot != null && ((Il2CppObjectBase)Rest.Spot).Pointer == ((Il2CppObjectBase)Spot).Pointer;
if (!num2 && !flag2)
{
ManualLogSource l2 = Plugin.L;
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(60, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[REST] stand menu closed (now locked into '");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>((lockedInInteraction == null) ? "nothing" : lockedInInteraction.GetName());
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("', passing time ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<bool>(instance.spendingTimeMode);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(")");
}
l2.LogInfo(val);
Active = false;
Cleanup();
HoldUntil = Time.unscaledTime + 1f;
StartGuard();
return;
}
float num3 = Vector3.Distance(((Component)instance).transform.position, standPos);
if (num3 > 3f && !loggedMove)
{
loggedMove = true;
ManualLogSource l3 = Plugin.L;
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(44, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[REST] moved ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(num3, "0.0");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" m while the watch menu is open");
}
l3.LogInfo(val);
}
return;
}
if (instance.spendingTimeMode && InteractionController.Instance.lockedInInteraction == null && !Rest.Own)
{
Plugin.L.LogInfo((object)"[REST] cleared a leftover pass-time state");
try
{
instance.SetSettingAlarmMode(false);
}
catch
{
}
try
{
instance.spendingTimeMode = false;
}
catch
{
}
}
if (!watch || instance.spendingTimeMode || InteractionController.Instance.lockedInInteraction != null)
{
stillSince = -1f;
return;
}
Vector3 position2 = ((Component)instance).transform.position;
if (stillSince < 0f || Vector3.Distance(position2, lastPos) > 0.05f)
{
stillSince = Time.unscaledTime;
lastPos = position2;
}
else if (!(Time.unscaledTime - stillSince < Plugin.StandingMenuDelay.Value))
{
stillSince = -1f;
Open(instance);
}
}
private static void StartGuard()
{
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
loggedMove = false;
GuardUntil = Time.unscaledTime + 10f;
guardPos = (((Object)(object)Player.Instance != (Object)null) ? ((Component)Player.Instance).transform.position : standPos);
}
private static void Open(Player p)
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Expected O, but got Unknown
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Unknown result type (might be due to invalid IL or missing references)
//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
//IL_00cd: Expected O, but got Unknown
//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
//IL_0113: Unknown result type (might be due to invalid IL or missing references)
//IL_0118: Unknown result type (might be due to invalid IL or missing references)
//IL_018d: Unknown result type (might be due to invalid IL or missing references)
//IL_0193: Expected O, but got Unknown
//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
try
{
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val;
if (p.spendingTimeMode || p.setAlarmMode)
{
ManualLogSource l = Plugin.L;
val = new BepInExInfoLogInterpolatedStringHandler(66, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[REST] stand menu: clearing leftover state (passing time ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<bool>(p.spendingTimeMode);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(", alarm ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<bool>(p.setAlarmMode);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(")");
}
l.LogInfo(val);
try
{
p.SetSettingAlarmMode(false);
}
catch
{
}
try
{
p.spendingTimeMode = false;
}
catch
{
}
}
standPos = ((Component)p).transform.position;
standRot = ((Component)p).transform.rotation;
InteractablePreset val2 = ChairPreset();
if ((SoCustomComparison)(object)val2 == (SoCustomComparison)null)
{
Plugin.L.LogInfo((object)"[REST] stand menu: no chair preset");
return;
}
spotObject = new GameObject("SkipTimeSpot");
spotObject.transform.position = ((Component)p).transform.position;
spotObject.transform.rotation = ((Component)p).transform.rotation;
Spot = InteractableCreator.Instance.CreateTransformInteractable(val2, spotObject.transform, (Human)null, (Evidence)null, Vector3.zero, Vector3.zero, (List<Passed>)null);
if (Spot == null)
{
Plugin.L.LogInfo((object)"[REST] stand menu: could not create the spot");
Cleanup();
return;
}
Active = true;
InteractionController.Instance.SetLockedInInteractionMode(Spot, 0, false);
ActionController.Instance.PassTime(Spot, Spot.node ?? ((Actor)p).currentNode, (Actor)(object)p);
ManualLogSource l2 = Plugin.L;
val = new BepInExInfoLogInterpolatedStringHandler(40, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[REST] stand menu open at your feet (");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(Vector3.Distance(Spot.wPos, ((Component)p).transform.position), "0.0");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" m)");
}
l2.LogInfo(val);
}
catch (Exception ex)
{
Active = false;
Cleanup();
Plugin.L.LogWarning((object)("[REST] stand menu failed: " + ex));
}
}
private static InteractablePreset? ChairPreset()
{
if ((SoCustomComparison)(object)chairPreset != (SoCustomComparison)null)
{
return chairPreset;
}
foreach (Object item in (Il2CppArrayBase<Object>)(object)Resources.FindObjectsOfTypeAll(Il2CppType.Of<InteractablePreset>()))
{
InteractablePreset val = ((Il2CppObjectBase)item).TryCast<InteractablePreset>();
if ((SoCustomComparison)(object)val != (SoCustomComparison)null && ((Object)val).name == "Chair")
{
chairPreset = val;
break;
}
}
return chairPreset;
}
private static void Cleanup()
{
try
{
Interactable? spot = Spot;
if (spot != null)
{
spot.SafeDelete(false);
}
}
catch
{
}
Spot = null;
try
{
if ((Object)(object)spotObject != (Object)null)
{
Object.Destroy((Object)(object)spotObject);
}
}
catch
{
}
spotObject = null;
}
internal static void Close()
{
Active = false;
try
{
Player.Instance.SetSettingAlarmMode(false);
}
catch
{
}
try
{
InteractionController.Instance.SetLockedInInteractionMode((Interactable)null, 0, false);
}
catch
{
}
Cleanup();
HoldUntil = Time.unscaledTime + 1f;
StartGuard();
Plugin.L.LogInfo((object)"[REST] stand menu: got up");
}
}
[HarmonyPatch]
internal static class StandMenuPatches
{
[HarmonyPatch(typeof(Interactable), "GetName")]
[HarmonyPostfix]
private static void Name(Interactable __instance, ref string __result)
{
Interactable spot = StandMenu.Spot;
if (spot != null && ((Il2CppObjectBase)__instance).Pointer == ((Il2CppObjectBase)spot).Pointer)
{
__result = "Watch";
}
}
[HarmonyPatch(typeof(Player), "TransformPlayerController")]
[HarmonyPrefix]
private static bool NoReturnWrite(Interactable newInteractable)
{
Interactable spot = StandMenu.Spot;
if (spot != null && newInteractable != null && ((Il2CppObjectBase)newInteractable).Pointer == ((Il2CppObjectBase)spot).Pointer)
{
Plugin.L.LogInfo((object)"[REST] standing rest: seat transition skipped, you stay where you are");
return false;
}
return true;
}
[HarmonyPatch(typeof(Player), "ReturnFromTransform")]
[HarmonyPrefix]
private static bool NoReturnMove()
{
if (StandMenu.Active || Time.unscaledTime < StandMenu.HoldUntil)
{
Plugin.L.LogInfo((object)"[REST] standing rest: return from seat skipped");
return false;
}
return true;
}
private static bool Holding()
{
if (!StandMenu.Active && !StandMenu.InGuard)
{
return Time.unscaledTime < StandMenu.HoldUntil;
}
return true;
}
[HarmonyPatch(typeof(PlayerUnstuck), "Update")]
[HarmonyPrefix]
private static void NotStuck(PlayerUnstuck __instance)
{
if (Holding())
{
try
{
__instance.currentAttemptedSecondsOfMovement = 0f;
}
catch
{
}
}
}
[HarmonyPatch(typeof(PlayerUnstuck), "UnstuckTeleportPlayer")]
[HarmonyPrefix]
private static bool NoUnstuck()
{
if (!Holding())
{
return true;
}
Plugin.L.LogInfo((object)"[REST] blocked the game's unstuck teleport");
return false;
}
[HarmonyPatch(typeof(ActionController), "Return")]
[HarmonyPrefix]
private static bool Return()
{
if (!StandMenu.Active)
{
return true;
}
StandMenu.Close();
return false;
}
}
internal static class SkipPrompts
{
internal const string Hour = "Skip One Hour";
internal const string All = "Skip To Alarm";
private static InteractionAction? all;
private static bool swapLogged;
private static bool logged;
private static InteractionAction? runAll;
private static InteractionAction? runHour;
internal static InteractionAction? toggleSrc;
internal static InteractionAction? forwardSrc;
private static bool runLogged;
internal static void Swap(Dictionary<InteractionKey, InteractableCurrentAction>? table)
{
//IL_0062: 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)
//IL_009e: Expected O, but got Unknown
//IL_00af: Unknown result type (might be due to invalid IL or missing references)
if (table == null || !Plugin.ReplaceHoursToggle.Value)
{
return;
}
Enumerator<InteractionKey, InteractableCurrentAction> enumerator = table.GetEnumerator();
bool flag = default(bool);
while (enumerator.MoveNext())
{
KeyValuePair<InteractionKey, InteractableCurrentAction> current = enumerator.Current;
InteractableCurrentAction value = current.Value;
InteractionAction val = ((value != null) ? value.currentAction : null);
if (((val != null) ? val.interactionName : null) != "Switch Hours/Minutes")
{
continue;
}
if (all == null)
{
all = Copy(val, "Skip To Alarm", val.useDefaultKeySetting, val.keyOverride);
}
current.Value.currentAction = all;
if (!swapLogged)
{
swapLogged = true;
ManualLogSource l = Plugin.L;
BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(38, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("[REST] prompt on ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<InteractionKey>(current.Key);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" is now Skip To Alarm");
}
l.LogInfo(val2);
}
}
}
internal static void AddTo(List<InteractionAction>? acts)
{
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
if (acts == null || !Plugin.ReplaceHoursToggle.Value)
{
return;
}
AddRunning(acts);
bool flag = false;
int num = -1;
for (int i = 0; i < acts.Count; i++)
{
InteractionAction obj = acts[i];
string text = ((obj != null) ? obj.interactionName : null);
if (text == "Skip To Alarm")
{
return;
}
if (text == "Alarm Forward")
{
flag = true;
if (forwardSrc == null)
{
forwardSrc = acts[i];
}
}
if (text == "Switch Hours/Minutes")
{
num = i;
if (toggleSrc == null)
{
toggleSrc = acts[i];
}
}
}
if (flag && num >= 0)
{
InteractionAction val = acts[num];
if (all == null)
{
all = Copy(val, "Skip To Alarm", val.useDefaultKeySetting, val.keyOverride);
}
acts[num] = all;
if (!logged)
{
logged = true;
Plugin.L.LogInfo((object)"[REST] Skip To Alarm replaces Switch Hours/Minutes in the pass-time menu");
}
}
}
private static void AddRunning(List<InteractionAction> acts)
{
//IL_0190: Unknown result type (might be due to invalid IL or missing references)
//IL_0197: Expected O, but got Unknown
bool flag = false;
try
{
flag = (Object)(object)Player.Instance != (Object)null && Player.Instance.spendingTimeMode && !Player.Instance.setAlarmMode;
}
catch
{
}
if (!flag)
{
for (int num = acts.Count - 1; num >= 0; num--)
{
if (acts[num] != null && ((runAll != null && ((Il2CppObjectBase)acts[num]).Pointer == ((Il2CppObjectBase)runAll).Pointer) || (runHour != null && ((Il2CppObjectBase)acts[num]).Pointer == ((Il2CppObjectBase)runHour).Pointer)))
{
acts.RemoveAt(num);
}
}
return;
}
InteractionAction val = null;
for (int i = 0; i < acts.Count; i++)
{
InteractionAction obj2 = acts[i];
switch ((obj2 != null) ? obj2.interactionName : null)
{
case "Skip One Hour":
return;
case "Cancel":
val = acts[i];
break;
}
}
if (val == null)
{
return;
}
if (toggleSrc != null)
{
if (runAll == null)
{
runAll = Slot(Mixed(val, toggleSrc, "Skip To Alarm"), Plugin.PromptAlarmSlot.Value);
}
acts.Add(runAll);
}
if (forwardSrc != null)
{
if (runHour == null)
{
runHour = Slot(Mixed(val, forwardSrc, "Skip One Hour"), Plugin.PromptHourSlot.Value);
}
acts.Add(runHour);
}
if (!runLogged)
{
runLogged = true;
ManualLogSource l = Plugin.L;
bool flag2 = default(bool);
BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(64, 2, ref flag2);
if (flag2)
{
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("[REST] prompts added while resting (alarm source ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<bool>(toggleSrc != null);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(", hour source ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<bool>(forwardSrc != null);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(")");
}
l.LogInfo(val2);
}
}
private static InteractionAction Slot(InteractionAction a, string slot)
{
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Expected O, but got Unknown
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
if (!string.IsNullOrWhiteSpace(slot) && Enum.TryParse<InteractionKey>(slot.Trim(), ignoreCase: true, out InteractionKey result) && (int)result != 0)
{
a.useDefaultKeySetting = false;
a.keyOverride = result;
}
ManualLogSource l = Plugin.L;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(20, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[REST] prompt '");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(a.interactionName);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("' on ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(a.useDefaultKeySetting ? "its default button" : ((object)a.keyOverride/*cast due to .constrained prefix*/).ToString());
}
l.LogInfo(val);
return a;
}
private static InteractionAction Mixed(InteractionAction shown, InteractionAction does, string name)
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
InteractionAction obj = Copy(shown, name, does.useDefaultKeySetting, does.keyOverride);
obj.action = does.action;
return obj;
}
private static InteractionAction Copy(InteractionAction src, string name, bool useDefault, InteractionKey key)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: 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_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: 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_0049: 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_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Expected O, but got Unknown
return new InteractionAction
{
interactionName = name,
action = src.action,
useDefaultKeySetting = useDefault,
keyOverride = key,
onlyActiveIf = src.onlyActiveIf,
effectSwitchStates = new List<SwitchState>(),
availableWhileLockedIn = src.availableWhileLockedIn,
availableWhileIllegal = true,
availableWhileWitnessesToIllegal = true,
specialCase = src.specialCase
};
}
}
[HarmonyPatch]
internal static class SkipPromptPatches
{
[HarmonyPatch(typeof(Interactable), "UpdateCurrentActions")]
[HarmonyPostfix]
private static void Current(Interactable __instance)
{
try
{
SkipPrompts.Swap(__instance.currentActions);
}
catch
{
}
}
[HarmonyPatch(typeof(InteractablePreset), "GetActions")]
[HarmonyPostfix]
private static void Actions(List<InteractionAction> __result)
{
try
{
SkipPrompts.AddTo(__result);
}
catch
{
}
}
[HarmonyPatch(typeof(Interactable), "OnInteraction", new Type[]
{
typeof(InteractionAction),
typeof(Actor),
typeof(bool),
typeof(float)
})]
[HarmonyPrefix]
private static bool Pressed(InteractionAction action)
{
string text = ((action != null) ? action.interactionName : null);
if ((text == "Skip One Hour" || text == "Skip To Alarm") && !Rest.Debounce())
{
return false;
}
if (text == "Skip One Hour")
{
Rest.Skip(1f, "one hour");
return false;
}
if (text == "Skip To Alarm")
{
float num = Rest.AlarmHoursAhead();
if (num <= 0.01f)
{
Rest.Note("Set the alarm on your watch first.");
}
else
{
Rest.Skip(num, "the alarm");
}
return false;
}
return true;
}
}
[HarmonyPatch]
internal static class SkipButtonPatches
{
private const string From = "Switch Hours/Minutes";
private static bool busy;
private static bool InAlarmMenu()
{
try
{
Player instance = Player.Instance;
return (Object)(object)instance != (Object)null && (instance.setAlarmMode || StandMenu.Active || InteractionController.Instance.lockedInInteraction != null);
}
catch
{
return false;
}
}
[HarmonyPatch(typeof(ActionController), "HoursMinutesToggle")]
[HarmonyPrefix]
private static bool Toggle()
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Expected O, but got Unknown
if (!Plugin.ReplaceHoursToggle.Value || !InAlarmMenu())
{
return true;
}
if (!Rest.Debounce())
{
return false;
}
float num = Rest.AlarmHoursAhead();
ManualLogSource l = Plugin.L;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(38, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[REST] Skip To Alarm pressed, ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(num, "0.00");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" h ahead");
}
l.LogInfo(val);
if (num <= 0.01f)
{
Rest.Note("Set the alarm on your watch first.");
}
else
{
Rest.Skip(num, "the alarm");
}
return false;
}
[HarmonyPatch(typeof(ActionController), "WatchForward")]
[HarmonyPrefix]
private static bool Forward()
{
bool flag = false;
try
{
flag = Player.Instance.spendingTimeMode && !Player.Instance.setAlarmMode;
}
catch
{
}
if (!flag)
{
return true;
}
if (Rest.Debounce())
{
Rest.Skip(1f, "one hour");
}
return false;
}
private static void Relabel(ControlDisplayController c)
{
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
if (busy || !Plugin.ReplaceHoursToggle.Value || (Object)(object)c == (Object)null)
{
return;
}
try
{
string actionName = c.actionName;
if (actionName != null && actionName.Contains("Switch Hours/Minutes"))
{
busy = true;
c.SetControlText(c.key, actionName.Replace("Switch Hours/Minutes", "Skip To Alarm"), false);
}
}
catch
{
}
finally
{
busy = false;
}
}
[HarmonyPatch(typeof(ControlDisplayController), "UpdateDisplay")]
[HarmonyPostfix]
private static void Display(ControlDisplayController __instance)
{
Relabel(__instance);
}
[HarmonyPatch(typeof(ControlDisplayController), "SetControlText")]
[HarmonyPostfix]
private static void Text(ControlDisplayController __instance)
{
Relabel(__instance);
}
}
[HarmonyPatch(typeof(Strings), "Get")]
internal static class PromptText
{
private static void Postfix(string key, ref string __result)
{
if (key == "Skip To Alarm")
{
__result = key + " (R)";
}
else if (key == "Skip One Hour")
{
__result = key + " (" + Plugin.WatchKey.Value + ")";
}
}
}
}
