using System;
using System.Collections;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ExitGames.Client.Photon;
using HarmonyLib;
using Photon.Pun;
using Photon.Realtime;
using UnityEngine;
using Zorro.Core;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyTitle("Vasodilation")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Vasodilation")]
[assembly: AssemblyCopyright("Copyright © 2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("15fa7750-965f-4249-837f-3d54157b5401")]
[assembly: AssemblyFileVersion("2.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.0.0.0")]
[module: UnverifiableCode]
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
namespace VasodilationMod
{
internal enum WarmthSource
{
None,
Sprint,
Jump,
SprintJump,
ClimbJump,
WallClimb,
RopeClimb,
VineClimb
}
[BepInPlugin("tony4twentys.Vasodilation", "Vasodilation", "2.0.0")]
[BepInProcess("PEAK.exe")]
public class VasodilationPlugin : BaseUnityPlugin
{
public const string PluginGuid = "tony4twentys.Vasodilation";
public const string PluginName = "Vasodilation";
public const string PluginVersion = "2.0.0";
internal const byte EventCode = 162;
internal const int ProtocolVersion = 3;
internal const string EventMagic = "tony4twentys.Vasodilation";
internal const int ConfigPayloadLength = 13;
internal static ConfigEntry<float> SprintRatio;
internal static ConfigEntry<float> JumpRatio;
internal static ConfigEntry<float> SprintJumpRatio;
internal static ConfigEntry<float> ClimbJumpRatio;
internal static ConfigEntry<float> WallClimbRatio;
internal static ConfigEntry<float> RopeClimbRatio;
internal static ConfigEntry<float> VineClimbRatio;
internal static ConfigEntry<float> EmoteColdPerSecond;
internal static ConfigEntry<float> GateOn;
internal static ConfigEntry<float> GateOff;
internal static ConfigEntry<bool> VerboseLogs;
internal static float syncedSprintRatio = 0.5f;
internal static float syncedJumpRatio = 0.25f;
internal static float syncedSprintJumpRatio = 0.25f;
internal static float syncedClimbJumpRatio = 0.25f;
internal static float syncedWallClimbRatio = 0.5f;
internal static float syncedRopeClimbRatio = 1f;
internal static float syncedVineClimbRatio = 0.75f;
internal static float syncedEmoteColdPerSecond = 0.01f;
internal static float syncedGateOn = 0.025f;
internal static float syncedGateOff = 0f;
internal static bool isHandshakeValid = true;
private Harmony _harmony;
private bool _warmingActive;
private bool _loggedTickError;
private bool _loggedStaminaError;
private float _nextEmoteLog;
private static readonly float[] NextSourceLog = new float[8];
private static float _alpineCachedAt = -999f;
private static bool _alpineCached;
internal static VasodilationPlugin Instance { get; private set; }
internal static ManualLogSource Log { get; private set; }
internal static bool IsGameplayEnabled
{
get
{
try
{
if (!PhotonNetwork.InRoom || PhotonNetwork.IsMasterClient)
{
return true;
}
}
catch
{
return isHandshakeValid;
}
return isHandshakeValid;
}
}
internal static bool DebugLogs
{
get
{
if (VerboseLogs != null)
{
return VerboseLogs.Value;
}
return false;
}
}
private void Awake()
{
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Expected O, but got Unknown
Instance = this;
Log = ((BaseUnityPlugin)this).Logger;
BindConfig();
ApplyLocalConfig();
if (!PhotonNetwork.InRoom || PhotonNetwork.IsMasterClient)
{
isHandshakeValid = true;
}
_harmony = new Harmony("tony4twentys.Vasodilation");
PatchAllSafe();
VasoNet.Ensure();
((BaseUnityPlugin)this).Config.SettingChanged += OnSettingChanged;
Log.LogInfo((object)string.Format("{0} v{1} loaded. Photon {2}.", "Vasodilation", "2.0.0", (byte)162));
}
private void Update()
{
try
{
TickEmoteWarmth(Time.deltaTime);
}
catch (Exception ex)
{
LogOnce(ref _loggedTickError, "[Vasodilation] Emote warmth tick failed.", ex);
}
}
private void BindConfig()
{
if ((0u | (DropOldConfig("General", "ColdPerSecond") ? 1u : 0u) | (DropOldConfig("General", "TickSeconds") ? 1u : 0u) | (DropOldConfig("General", "StaminaToColdRatio") ? 1u : 0u) | (DropOldConfig("General", "EmoteColdPerSecond") ? 1u : 0u)) != 0)
{
((BaseUnityPlugin)this).Config.Save();
}
SprintRatio = BindWarmthRatio("Sprint", 0.5f, "Grounded sprint.");
JumpRatio = BindWarmthRatio("Jump", 0.25f, "Standing jump.");
SprintJumpRatio = BindWarmthRatio("SprintJump", 0.25f, "Jump while sprinting.");
ClimbJumpRatio = BindWarmthRatio("ClimbJump", 0.25f, "Wall sprint-boost. Alpine walls are ignored.");
WallClimbRatio = BindWarmthRatio("WallClimb", 0.5f, "Wall hang, move, or re-grab. Alpine walls are ignored.");
RopeClimbRatio = BindWarmthRatio("RopeClimb", 1f, "Climbing up a rope. Hang and climb-down are ignored.");
VineClimbRatio = BindWarmthRatio("VineClimb", 0.75f, "Climbing a vine. Hang, slide, and grab are ignored.");
EmoteColdPerSecond = ((BaseUnityPlugin)this).Config.Bind<float>("Warmth", "EmoteColdPerSecond", 0.01f, "Host only. Cold removed per second during Dance, Crashout, Shimmy, Backflip, Wave, or Bully. Emotes do not use stamina. Host value is synced to the room.");
GateOn = ((BaseUnityPlugin)this).Config.Bind<float>("General", "ColdGateOn", 0.025f, "Host only. Start warming once Cold is above this. Host value is synced to the room.");
GateOff = ((BaseUnityPlugin)this).Config.Bind<float>("General", "ColdGateOff", 0f, "Host only. Stop warming once Cold is at or below this. Host value is synced to the room.");
VerboseLogs = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "VerboseLogs", false, "Local only. Log warmth about once per second per move. Not host-synced.");
}
private ConfigEntry<float> BindWarmthRatio(string key, float defaultValue, string what)
{
return ((BaseUnityPlugin)this).Config.Bind<float>("Warmth", key, defaultValue, "Host only. Cold removed per stamina spent: " + what + " 0.5 = half, 1 = 1:1. Host value is synced to the room.");
}
private bool DropOldConfig(string section, string key)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Expected O, but got Unknown
ConfigDefinition val = new ConfigDefinition(section, key);
if (!((BaseUnityPlugin)this).Config.ContainsKey(val))
{
return false;
}
((BaseUnityPlugin)this).Config.Remove(val);
return true;
}
private void OnSettingChanged(object sender, SettingChangedEventArgs args)
{
if (args == null || (object)args.ChangedSetting != VerboseLogs)
{
VasoNet.OnLocalSettingChanged();
}
}
internal static void ApplyLocalConfig()
{
ApplySyncedValues(GateOn.Value, GateOff.Value, EmoteColdPerSecond.Value, SprintRatio.Value, JumpRatio.Value, SprintJumpRatio.Value, ClimbJumpRatio.Value, WallClimbRatio.Value, RopeClimbRatio.Value, VineClimbRatio.Value);
}
internal static object[] BuildConfigPayload(byte sub)
{
return new object[13]
{
"tony4twentys.Vasodilation", 3, sub, GateOn.Value, GateOff.Value, EmoteColdPerSecond.Value, SprintRatio.Value, JumpRatio.Value, SprintJumpRatio.Value, ClimbJumpRatio.Value,
WallClimbRatio.Value, RopeClimbRatio.Value, VineClimbRatio.Value
};
}
internal static void ApplyRemoteConfig(object[] arr)
{
if (arr == null || arr.Length < 13)
{
throw new InvalidOperationException("Vasodilation config payload too short.");
}
ApplySyncedValues(Convert.ToSingle(arr[3]), Convert.ToSingle(arr[4]), Convert.ToSingle(arr[5]), Convert.ToSingle(arr[6]), Convert.ToSingle(arr[7]), Convert.ToSingle(arr[8]), Convert.ToSingle(arr[9]), Convert.ToSingle(arr[10]), Convert.ToSingle(arr[11]), Convert.ToSingle(arr[12]));
}
private static void ApplySyncedValues(float gateOn, float gateOff, float emote, float sprint, float jump, float sprintJump, float climbJump, float wall, float rope, float vine)
{
syncedGateOn = Mathf.Max(0f, gateOn);
syncedGateOff = Mathf.Max(0f, gateOff);
syncedEmoteColdPerSecond = Mathf.Max(0f, emote);
syncedSprintRatio = Mathf.Max(0f, sprint);
syncedJumpRatio = Mathf.Max(0f, jump);
syncedSprintJumpRatio = Mathf.Max(0f, sprintJump);
syncedClimbJumpRatio = Mathf.Max(0f, climbJump);
syncedWallClimbRatio = Mathf.Max(0f, wall);
syncedRopeClimbRatio = Mathf.Max(0f, rope);
syncedVineClimbRatio = Mathf.Max(0f, vine);
if (syncedGateOff > syncedGateOn)
{
syncedGateOff = syncedGateOn;
}
}
internal static void DebugLog(string message)
{
if (DebugLogs)
{
ManualLogSource log = Log;
if (log != null)
{
log.LogInfo((object)message);
}
}
}
internal static void LogOnce(ref bool flag, string message, Exception ex)
{
if (flag)
{
return;
}
flag = true;
if (ex != null)
{
ManualLogSource log = Log;
if (log != null)
{
log.LogError((object)(message + " " + ex));
}
}
else
{
ManualLogSource log2 = Log;
if (log2 != null)
{
log2.LogError((object)message);
}
}
}
internal static void OnStaminaSpent(Character character, float spent)
{
VasodilationPlugin instance = Instance;
if ((Object)(object)instance == (Object)null)
{
return;
}
try
{
instance.TryWarmFromStamina(character, spent);
}
catch (Exception ex)
{
LogOnce(ref instance._loggedStaminaError, "[Vasodilation] Stamina warmth failed.", ex);
}
}
private void TryWarmFromStamina(Character character, float spent)
{
if (spent <= 1E-05f || !IsGameplayEnabled || !CanWarm(character))
{
return;
}
WarmthSource warmthSource = GetWarmthSource(character);
if (warmthSource != WarmthSource.None && UpdateWarmingGate(character))
{
float num = spent * GetSyncedRatio(warmthSource);
if (!(num <= 0f))
{
character.refs.afflictions.SubtractStatus((STATUSTYPE)2, num, false, false);
MaybeLogWarmth(warmthSource, spent, num);
}
}
}
private void TickEmoteWarmth(float deltaTime)
{
if (deltaTime <= 0f || syncedEmoteColdPerSecond <= 0f || !IsGameplayEnabled)
{
return;
}
Character localCharacter = Character.localCharacter;
if (!EmoteWarmth.IsWarming(localCharacter) || !CanWarm(localCharacter) || !UpdateWarmingGate(localCharacter))
{
return;
}
float num = syncedEmoteColdPerSecond * deltaTime;
if (!(num <= 0f))
{
localCharacter.refs.afflictions.SubtractStatus((STATUSTYPE)2, num, false, false);
if (DebugLogs && Time.unscaledTime >= _nextEmoteLog)
{
_nextEmoteLog = Time.unscaledTime + 1f;
DebugLog("[Vasodilation] emote coldDelta=" + num.ToString("0.####"));
}
}
}
private bool CanWarm(Character character)
{
if ((Object)(object)character == (Object)null || !character.IsLocal)
{
return false;
}
if ((Object)(object)character.data == (Object)null || character.refs == null || (Object)(object)character.refs.afflictions == (Object)null)
{
return false;
}
if (character.data.dead)
{
return false;
}
return true;
}
private bool UpdateWarmingGate(Character character)
{
float currentStatus = character.refs.afflictions.GetCurrentStatus((STATUSTYPE)2);
if (currentStatus <= syncedGateOff)
{
_warmingActive = false;
}
else if (currentStatus > syncedGateOn)
{
_warmingActive = true;
}
return _warmingActive;
}
internal static WarmthSource GetWarmthSource(Character character)
{
if ((Object)(object)character == (Object)null || (Object)(object)character.data == (Object)null)
{
return WarmthSource.None;
}
CharacterData data = character.data;
if (WarmthSpendMark.Ignore)
{
return WarmthSource.None;
}
if (WarmthSpendMark.ClimbJump)
{
if (!IsAlpine())
{
return WarmthSource.ClimbJump;
}
return WarmthSource.None;
}
if (data.isJumping)
{
if (!data.isSprinting)
{
return WarmthSource.Jump;
}
return WarmthSource.SprintJump;
}
if (data.isRopeClimbing)
{
if (!IsClimbingRopeUp(character))
{
return WarmthSource.None;
}
return WarmthSource.RopeClimb;
}
if (data.isVineClimbing)
{
if (!IsClimbingVine(character))
{
return WarmthSource.None;
}
return WarmthSource.VineClimb;
}
if (data.isClimbing)
{
if (!IsAlpine())
{
return WarmthSource.WallClimb;
}
return WarmthSource.None;
}
if (data.isSprinting)
{
return WarmthSource.Sprint;
}
return WarmthSource.None;
}
internal static float GetSyncedRatio(WarmthSource source)
{
return source switch
{
WarmthSource.Sprint => syncedSprintRatio,
WarmthSource.Jump => syncedJumpRatio,
WarmthSource.SprintJump => syncedSprintJumpRatio,
WarmthSource.ClimbJump => syncedClimbJumpRatio,
WarmthSource.WallClimb => syncedWallClimbRatio,
WarmthSource.RopeClimb => syncedRopeClimbRatio,
WarmthSource.VineClimb => syncedVineClimbRatio,
_ => 0f,
};
}
private static bool IsClimbingRopeUp(Character character)
{
if ((Object)(object)character == (Object)null || (Object)(object)character.input == (Object)null)
{
return false;
}
return character.input.movementInput.y > 0.01f;
}
private static bool IsClimbingVine(Character character)
{
if ((Object)(object)character == (Object)null || (Object)(object)character.input == (Object)null)
{
return false;
}
if (character.refs != null && (Object)(object)character.refs.vineClimbing != (Object)null && character.refs.vineClimbing.Sliding())
{
return false;
}
return Mathf.Abs(character.input.movementInput.y) >= 0.01f;
}
private void MaybeLogWarmth(WarmthSource source, float spent, float amount)
{
if (!DebugLogs)
{
return;
}
if (source >= WarmthSource.None && (int)source < NextSourceLog.Length)
{
float unscaledTime = Time.unscaledTime;
if (!(spent < 0.02f) || !(unscaledTime < NextSourceLog[(int)source]))
{
NextSourceLog[(int)source] = unscaledTime + 1f;
DebugLog($"[Vasodilation] stam={spent:0.####} coldDelta={amount:0.####} source={source}");
}
}
}
internal static bool IsAlpine()
{
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Invalid comparison between Unknown and I4
float unscaledTime = Time.unscaledTime;
if (unscaledTime - _alpineCachedAt < 0.5f)
{
return _alpineCached;
}
_alpineCachedAt = unscaledTime;
try
{
MapHandler instance = Singleton<MapHandler>.Instance;
_alpineCached = (Object)(object)instance != (Object)null && (int)instance.GetCurrentBiome() == 2;
}
catch
{
_alpineCached = false;
}
return _alpineCached;
}
private void PatchAllSafe()
{
Type[] types = typeof(VasodilationPlugin).Assembly.GetTypes();
foreach (Type type in types)
{
if (!(type == null) && type.GetCustomAttributes(typeof(HarmonyPatch), inherit: false).Length != 0)
{
try
{
_harmony.CreateClassProcessor(type).Patch();
}
catch (Exception ex)
{
Log.LogError((object)("[Vasodilation] Patch failed on " + type.Name + ": " + ex.Message));
}
}
}
}
}
internal sealed class VasoNet : MonoBehaviourPunCallbacks, IOnEventCallback
{
private const byte SubConfig = 1;
private const byte SubConfigRequest = 2;
private const float HostSyncTimeoutSeconds = 12f;
private const float HostSyncRetrySeconds = 2f;
internal static bool HostModConfirmed;
private Coroutine _debounce;
private Coroutine _hostSyncWatch;
private bool _syncingFromNet;
internal static VasoNet Instance { get; private set; }
internal static void Ensure()
{
//IL_0013: 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_001e: Expected O, but got Unknown
if ((Object)(object)Instance != (Object)null)
{
return;
}
GameObject val = new GameObject("Vasodilation_Net");
Object.DontDestroyOnLoad((Object)val);
Instance = val.AddComponent<VasoNet>();
try
{
if (PhotonNetwork.InRoom)
{
Instance.HandleJoinedRoom();
}
}
catch
{
}
}
private void Awake()
{
Instance = this;
}
public override void OnEnable()
{
((MonoBehaviourPunCallbacks)this).OnEnable();
PhotonNetwork.AddCallbackTarget((object)this);
}
public override void OnDisable()
{
PhotonNetwork.RemoveCallbackTarget((object)this);
((MonoBehaviourPunCallbacks)this).OnDisable();
}
public override void OnJoinedRoom()
{
HandleJoinedRoom();
}
public override void OnLeftRoom()
{
StopHostSyncWatch();
HostModConfirmed = false;
VasodilationPlugin.isHandshakeValid = true;
VasodilationPlugin.ApplyLocalConfig();
}
public override void OnMasterClientSwitched(Player newMasterClient)
{
if (PhotonNetwork.IsMasterClient)
{
HostModConfirmed = true;
VasodilationPlugin.isHandshakeValid = true;
VasodilationPlugin.ApplyLocalConfig();
BroadcastNow();
StopHostSyncWatch();
}
else
{
HostModConfirmed = false;
VasodilationPlugin.isHandshakeValid = false;
RequestHostSync();
RestartHostSyncWatch();
}
}
public override void OnPlayerEnteredRoom(Player newPlayer)
{
if (PhotonNetwork.IsMasterClient)
{
((MonoBehaviour)this).StartCoroutine(BroadcastAfterDelay(0.5f));
}
}
public void OnEvent(EventData photonEvent)
{
if (photonEvent == null || photonEvent.Code != 162 || !(photonEvent.CustomData is object[] array) || array.Length < 3 || !(array[0] is string text) || text != "tony4twentys.Vasodilation" || ToInt(array[1]) != 3)
{
return;
}
byte b = ToByte(array[2]);
if (b == 2 && PhotonNetwork.IsMasterClient)
{
BroadcastNow();
}
else
{
if (b != 1 || PhotonNetwork.IsMasterClient)
{
return;
}
try
{
_syncingFromNet = true;
VasodilationPlugin.ApplyRemoteConfig(array);
StopHostSyncWatch();
HostModConfirmed = true;
VasodilationPlugin.isHandshakeValid = true;
VasodilationPlugin.Log.LogInfo((object)"[Vasodilation] Host config sync applied.");
}
catch (Exception ex)
{
VasodilationPlugin.Log.LogError((object)("[Vasodilation] Config sync failed: " + ex.Message));
}
finally
{
_syncingFromNet = false;
}
}
}
internal static void OnLocalSettingChanged()
{
if (!((Object)(object)Instance != (Object)null) || !Instance._syncingFromNet)
{
if (!PhotonNetwork.InRoom || PhotonNetwork.IsMasterClient)
{
VasodilationPlugin.ApplyLocalConfig();
}
ScheduleBroadcast();
}
}
internal static void ScheduleBroadcast()
{
if (!((Object)(object)Instance == (Object)null) && PhotonNetwork.InRoom && PhotonNetwork.IsMasterClient)
{
if (Instance._debounce != null)
{
((MonoBehaviour)Instance).StopCoroutine(Instance._debounce);
}
Instance._debounce = ((MonoBehaviour)Instance).StartCoroutine(Instance.DebounceBroadcast());
}
}
private void HandleJoinedRoom()
{
if (PhotonNetwork.IsMasterClient)
{
HostModConfirmed = true;
VasodilationPlugin.isHandshakeValid = true;
VasodilationPlugin.ApplyLocalConfig();
BroadcastNow();
StopHostSyncWatch();
}
else
{
HostModConfirmed = false;
VasodilationPlugin.isHandshakeValid = false;
RequestHostSync();
RestartHostSyncWatch();
}
}
private static void RequestHostSync()
{
//IL_0034: 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)
//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_004a: Expected O, but got Unknown
if (PhotonNetwork.InRoom && !PhotonNetwork.IsMasterClient)
{
PhotonNetwork.RaiseEvent((byte)162, (object)new object[3]
{
"tony4twentys.Vasodilation",
3,
(byte)2
}, new RaiseEventOptions
{
Receivers = (ReceiverGroup)2
}, SendOptions.SendReliable);
}
}
private void RestartHostSyncWatch()
{
StopHostSyncWatch();
if (PhotonNetwork.InRoom && !PhotonNetwork.IsMasterClient)
{
_hostSyncWatch = ((MonoBehaviour)this).StartCoroutine(WatchForHostSync());
}
}
private void StopHostSyncWatch()
{
if (_hostSyncWatch != null)
{
((MonoBehaviour)this).StopCoroutine(_hostSyncWatch);
_hostSyncWatch = null;
}
}
private IEnumerator WatchForHostSync()
{
float elapsed = 0f;
float nextRetry = 2f;
while (elapsed < 12f)
{
if (!PhotonNetwork.InRoom || PhotonNetwork.IsMasterClient || HostModConfirmed)
{
yield break;
}
elapsed += Time.unscaledDeltaTime;
if (elapsed >= nextRetry)
{
RequestHostSync();
nextRetry += 2f;
}
yield return null;
}
if (PhotonNetwork.InRoom && !PhotonNetwork.IsMasterClient && !HostModConfirmed)
{
VasodilationPlugin.isHandshakeValid = false;
VasodilationPlugin.Log.LogWarning((object)"[Vasodilation] Host does not appear to have Vasodilation — warmth disabled.");
}
_hostSyncWatch = null;
}
private IEnumerator DebounceBroadcast()
{
yield return (object)new WaitForSeconds(0.25f);
BroadcastNow();
_debounce = null;
}
private IEnumerator BroadcastAfterDelay(float seconds)
{
yield return (object)new WaitForSeconds(seconds);
BroadcastNow();
}
private static void BroadcastNow()
{
//IL_001a: 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: 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_0030: Expected O, but got Unknown
if (PhotonNetwork.InRoom && PhotonNetwork.IsMasterClient)
{
PhotonNetwork.RaiseEvent((byte)162, (object)VasodilationPlugin.BuildConfigPayload(1), new RaiseEventOptions
{
Receivers = (ReceiverGroup)0
}, SendOptions.SendReliable);
}
}
private static int ToInt(object value)
{
return Convert.ToInt32(value);
}
private static byte ToByte(object value)
{
return Convert.ToByte(value);
}
}
internal static class EmoteWarmth
{
internal static bool LastIsWarming;
private static readonly string[] WarmTokens = new string[6] { "dance", "crashout", "shimmy", "backflip", "wave", "bully" };
internal static bool IsWarmingName(string emoteName)
{
if (string.IsNullOrEmpty(emoteName))
{
return false;
}
string text = emoteName.ToLowerInvariant();
for (int i = 0; i < WarmTokens.Length; i++)
{
if (text.IndexOf(WarmTokens[i], StringComparison.Ordinal) >= 0)
{
return true;
}
}
return false;
}
internal static bool IsWarming(Character character)
{
if (!LastIsWarming)
{
return false;
}
if ((Object)(object)character == (Object)null || character.refs == null || (Object)(object)character.refs.animations == (Object)null)
{
return false;
}
return character.refs.animations.emoting;
}
internal static void Remember(CharacterAnimations animations, string emoteName)
{
if (!((Object)(object)animations == (Object)null) && !string.IsNullOrEmpty(emoteName))
{
Character character = animations.character;
if (!((Object)(object)character == (Object)null) && character.IsLocal)
{
LastIsWarming = IsWarmingName(emoteName);
}
}
}
}
internal static class WarmthSpendMark
{
internal static bool Ignore;
internal static bool ClimbJump;
}
[HarmonyPatch(typeof(CharacterVineClimbing), "GrabVineRpc")]
internal static class VineGrabSkipPatch
{
private static void Prefix()
{
WarmthSpendMark.Ignore = true;
}
private static Exception Finalizer(Exception __exception)
{
WarmthSpendMark.Ignore = false;
return __exception;
}
}
[HarmonyPatch(typeof(CharacterGrabbing), "KickCast")]
internal static class KickSkipPatch
{
private static void Prefix()
{
WarmthSpendMark.Ignore = true;
}
private static Exception Finalizer(Exception __exception)
{
WarmthSpendMark.Ignore = false;
return __exception;
}
}
[HarmonyPatch(typeof(CharacterClimbing), "RPCA_ClimbJump")]
internal static class ClimbJumpMarkPatch
{
private static void Prefix()
{
WarmthSpendMark.ClimbJump = true;
}
private static Exception Finalizer(Exception __exception)
{
WarmthSpendMark.ClimbJump = false;
return __exception;
}
}
[HarmonyPatch(typeof(Character), "UseStamina")]
internal static class UseStaminaWarmthPatch
{
private static bool _logged;
private static void Prefix(Character __instance, out float __state)
{
__state = -1f;
try
{
if (!((Object)(object)__instance == (Object)null) && __instance.IsLocal)
{
__state = __instance.GetTotalStamina();
}
}
catch (Exception ex)
{
VasodilationPlugin.LogOnce(ref _logged, "[Vasodilation] UseStamina prefix failed.", ex);
}
}
private static void Postfix(Character __instance, float __state)
{
if (__state < 0f || (Object)(object)__instance == (Object)null)
{
return;
}
try
{
float num = __state - __instance.GetTotalStamina();
if (num > 1E-05f)
{
VasodilationPlugin.OnStaminaSpent(__instance, num);
}
}
catch (Exception ex)
{
VasodilationPlugin.LogOnce(ref _logged, "[Vasodilation] UseStamina postfix failed.", ex);
}
}
}
[HarmonyPatch(typeof(CharacterAnimations), "RPCA_PlayRemove")]
internal static class EmotePlayPatch
{
private static bool _logged;
private static void Postfix(CharacterAnimations __instance, string emoteName)
{
try
{
EmoteWarmth.Remember(__instance, emoteName);
}
catch (Exception ex)
{
VasodilationPlugin.LogOnce(ref _logged, "[Vasodilation] Emote postfix failed.", ex);
}
}
}
[HarmonyPatch(typeof(CharacterAnimations), "PlayEmote")]
internal static class EmoteLocalPlayPatch
{
private static bool _logged;
private static void Postfix(CharacterAnimations __instance, string emoteName)
{
try
{
EmoteWarmth.Remember(__instance, emoteName);
}
catch (Exception ex)
{
VasodilationPlugin.LogOnce(ref _logged, "[Vasodilation] PlayEmote postfix failed.", ex);
}
}
}
}
