using System;
using System.Diagnostics;
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 Peak.Afflictions;
using Photon.Pun;
using Photon.Realtime;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("com.github.legocool.StaminaLinked")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0")]
[assembly: AssemblyProduct("com.github.legocool.StaminaLinked")]
[assembly: AssemblyTitle("StaminaLinked")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.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.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]
[Microsoft.CodeAnalysis.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]
[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 BepInEx
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
internal sealed class BepInAutoPluginAttribute : Attribute
{
public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace BepInEx.Preloader.Core.Patching
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
internal sealed class PatcherAutoPluginAttribute : Attribute
{
public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace StaminaLinked
{
[BepInPlugin("legocool.StaminaLinked", "StaminaLinked", "0.2.0")]
public class StaminaLinked : BaseUnityPlugin
{
[HarmonyPatch(typeof(Character), "UseStamina")]
public static class Patch_UseStamina
{
private static bool Prefix(Character __instance, float usage, bool useBonusStamina)
{
if (!__instance.view.IsMine)
{
return false;
}
if (!PhotonNetwork.IsMasterClient && staminaUseToggle.Value)
{
((MonoBehaviourPun)StaminaSync.Instance).photonView.RPC("RPC_RequestUseStamina", (RpcTarget)2, new object[2] { usage, useBonusStamina });
}
return true;
}
private static void Postfix(CharacterAfflictions __instance, float usage, bool useBonusStamina)
{
if (PhotonNetwork.IsMasterClient && staminaUseToggle.Value)
{
StaminaSync.Instance.BroadcastStamina();
}
}
}
[HarmonyPatch(typeof(Character), "AddExtraStamina")]
public static class Patch_AddExtraStamina
{
private static bool Prefix(Character __instance, float add)
{
if (!__instance.view.IsMine)
{
return false;
}
if (!PhotonNetwork.IsMasterClient)
{
((MonoBehaviourPun)StaminaSync.Instance).photonView.RPC("RPC_RequestAddExtraStamina", (RpcTarget)2, new object[1] { add });
}
return true;
}
private static void Postfix(CharacterAfflictions __instance, float add)
{
if (PhotonNetwork.IsMasterClient)
{
StaminaSync.Instance.BroadcastStamina();
}
}
}
[HarmonyPatch(typeof(Character), "SetExtraStamina")]
public static class Patch_SetExtraStamina
{
private static bool Prefix(Character __instance, float amt)
{
if (!__instance.view.IsMine)
{
return false;
}
if (!PhotonNetwork.IsMasterClient)
{
((MonoBehaviourPun)StaminaSync.Instance).photonView.RPC("RPC_RequestSetExtraStamina", (RpcTarget)2, new object[1] { amt });
}
return true;
}
private static void Postfix(CharacterAfflictions __instance, float amt)
{
if (PhotonNetwork.IsMasterClient)
{
StaminaSync.Instance.BroadcastStamina();
}
}
}
[HarmonyPatch(typeof(CharacterAfflictions), "SubtractStatus")]
public static class Patch_SubtractStatus
{
private static bool Prefix(CharacterAfflictions __instance, STATUSTYPE statusType, float amount, bool fromRPC = false)
{
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Expected I4, but got Unknown
if (!__instance.character.view.IsMine)
{
return false;
}
if (!PhotonNetwork.IsMasterClient)
{
((MonoBehaviourPun)StaminaSync.Instance).photonView.RPC("RPC_RequestSubtractStatus", (RpcTarget)2, new object[2]
{
(int)statusType,
amount
});
}
return true;
}
private static void Postfix(CharacterAfflictions __instance, STATUSTYPE statusType, float amount, bool fromRPC = false)
{
if (PhotonNetwork.IsMasterClient)
{
StaminaSync.Instance.BroadcastStatuses();
}
}
}
[HarmonyPatch(typeof(CharacterAfflictions), "AddStatus")]
public static class Patch_AddStatus
{
private static bool Prefix(CharacterAfflictions __instance, STATUSTYPE statusType, ref float amount, bool fromRPC = false)
{
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Invalid comparison between Unknown and I4
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Invalid comparison between Unknown and I4
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Expected I4, but got Unknown
if (!__instance.character.view.IsMine)
{
return false;
}
if (!PhotonNetwork.IsMasterClient)
{
if ((int)statusType == 1)
{
return false;
}
((MonoBehaviourPun)StaminaSync.Instance).photonView.RPC("RPC_RequestAddStatus", (RpcTarget)2, new object[2]
{
(int)statusType,
amount
});
}
if ((int)statusType == 1)
{
amount *= PlayerHandler.GetAllPlayers().Count;
}
return true;
}
private static void Postfix(CharacterAfflictions __instance, STATUSTYPE statusType, float amount, bool fromRPC = false)
{
if (PhotonNetwork.IsMasterClient)
{
StaminaSync.Instance.BroadcastStatuses();
}
}
}
[HarmonyPatch(typeof(CharacterAfflictions), "SetStatus")]
public static class Patch_SetStatus
{
private static bool Prefix(CharacterAfflictions __instance, STATUSTYPE statusType, float amount)
{
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Expected I4, but got Unknown
if (!__instance.character.view.IsMine)
{
return false;
}
if (!PhotonNetwork.IsMasterClient)
{
((MonoBehaviourPun)StaminaSync.Instance).photonView.RPC("RPC_RequestSetStatus", (RpcTarget)2, new object[2]
{
(int)statusType,
amount
});
}
return true;
}
private static void Postfix(CharacterAfflictions __instance, STATUSTYPE statusType, float amount)
{
if (PhotonNetwork.IsMasterClient)
{
StaminaSync.Instance.BroadcastStatuses();
}
}
}
[HarmonyPatch(typeof(CharacterAfflictions), "UpdateWeight")]
public static class Patch_UpdateWeight
{
private static bool Prefix(CharacterAfflictions __instance)
{
calcWeight();
return false;
}
}
[HarmonyPatch(typeof(Action_ApplyInfiniteStamina), "RunAction")]
public static class Patch_ApplyInfiniteStamina
{
private static bool Prefix(Action_ApplyInfiniteStamina __instance)
{
if (!((ItemActionBase)__instance).character.view.IsMine)
{
return false;
}
if (!PhotonNetwork.IsMasterClient)
{
((MonoBehaviourPun)StaminaSync.Instance).photonView.RPC("RPC_RequestInfiniteStamina", (RpcTarget)2, new object[1] { __instance.buffTime });
return false;
}
((MonoBehaviourPun)StaminaSync.Instance).photonView.RPC("RPC_ApplyInfiniteStamina", (RpcTarget)1, new object[1] { __instance.buffTime });
return false;
}
}
[HarmonyPatch(typeof(Character), "UpdateVariablesFixed")]
public static class Patch_MoreStaminaRegen
{
private static void Postfix(Character __instance)
{
if (__instance.CanRegenStamina())
{
float num = 0.2f * staminaRegenModifier.Value;
__instance.AddStamina(Time.fixedDeltaTime * num);
}
}
}
[HarmonyPatch(typeof(Character), "CanRegenStamina")]
public static class Patch_CanRegenStamina
{
private static bool Prefix(Character __instance, ref bool __result)
{
if (staminaUseToggle.Value)
{
return true;
}
foreach (Character allPlayerCharacter in PlayerHandler.GetAllPlayerCharacters())
{
if (!Object.op_Implicit((Object)(object)allPlayerCharacter.data.currentClimbHandle) && !allPlayerCharacter.IsStuck())
{
float num = ((allPlayerCharacter.data.currentStamina > 0f) ? 1f : 2f);
if (!(allPlayerCharacter.data.sinceGrounded <= 0.2f) || !(allPlayerCharacter.data.sinceUseStamina >= num))
{
__result = false;
return false;
}
}
}
__result = true;
return false;
}
}
[HarmonyPatch(typeof(Player), "OnPlayerEnteredRoom")]
public static class Patch_SyncConfig
{
private static void Postfix(Player __instance, Player newPlayer)
{
if (PhotonNetwork.IsMasterClient)
{
((MonoBehaviourPun)StaminaSync.Instance).photonView.RPC("RPC_SyncConfig", newPlayer, new object[3] { staminaUseToggle.Value, backpackModifier.Value, staminaRegenModifier.Value });
}
}
}
private Harmony _harmony;
public static ConfigEntry<bool> staminaUseToggle;
public static ConfigEntry<float> backpackModifier;
public static ConfigEntry<float> staminaRegenModifier;
internal static ManualLogSource Log { get; private set; }
private void Awake()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Expected O, but got Unknown
Log = ((BaseUnityPlugin)this).Logger;
_harmony = new Harmony("legocool.StaminaLinked");
_harmony.PatchAll();
GameObject val = new GameObject("StaminaSyncManager");
Object.DontDestroyOnLoad((Object)(object)val);
val.AddComponent<StaminaSync>();
PhotonView val2 = val.AddComponent<PhotonView>();
val2.ViewID = 999999999;
staminaUseToggle = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Stamina Use Sharing", true, "Whether stamina use should be shared or not.");
backpackModifier = ((BaseUnityPlugin)this).Config.Bind<float>("Modifiers", "Backpack weight modifier", 0.5f, "The weight modifier of the items in the backpack. 0.5 = 50% less");
staminaRegenModifier = ((BaseUnityPlugin)this).Config.Bind<float>("Modifiers", "Stamina regeneration modifier", 0.5f, "Modifier for how fast stamina willl regen. 0.5 = 50% faster");
Log.LogInfo((object)"Plugin StaminaLinked is loaded!");
}
private void OnDestroy()
{
_harmony.UnpatchSelf();
}
public static void calcWeight()
{
int num = 0;
int num2 = 0;
BackpackData val2 = default(BackpackData);
foreach (Character allPlayerCharacter in PlayerHandler.GetAllPlayerCharacters())
{
int num3 = 0;
int num4 = 0;
float currentStatus = allPlayerCharacter.refs.afflictions.GetCurrentStatus((STATUSTYPE)9);
for (int i = 0; i < allPlayerCharacter.player.itemSlots.Length; i++)
{
ItemSlot val = allPlayerCharacter.player.itemSlots[i];
if ((Object)(object)val.prefab != (Object)null)
{
num3 += val.prefab.CarryWeight;
}
}
BackpackSlot backpackSlot = allPlayerCharacter.player.backpackSlot;
if (!((ItemSlot)backpackSlot).IsEmpty() && ((ItemSlot)backpackSlot).data.TryGetDataEntry<BackpackData>((DataEntryKey)7, ref val2))
{
for (int j = 0; j < val2.itemSlots.Length; j++)
{
ItemSlot val3 = val2.itemSlots[j];
if (!val3.IsEmpty())
{
num3 += (int)((float)val3.prefab.CarryWeight * backpackModifier.Value);
}
}
}
ItemSlot itemSlot = allPlayerCharacter.player.GetItemSlot((byte)250);
if (!itemSlot.IsEmpty())
{
num3 += itemSlot.prefab.CarryWeight;
}
if ((Object)(object)allPlayerCharacter.data.carriedPlayer != (Object)null)
{
num3 += 8;
}
foreach (StickyItemComponent aLL_STUCK_ITEM in StickyItemComponent.ALL_STUCK_ITEMS)
{
if ((Object)(object)aLL_STUCK_ITEM.stuckToCharacter == (Object)(object)allPlayerCharacter)
{
num3 += aLL_STUCK_ITEM.addWeightToStuckPlayer;
num4 += aLL_STUCK_ITEM.addThornsToStuckPlayer;
}
}
if (Object.op_Implicit((Object)(object)allPlayerCharacter.data.currentStickyItem))
{
num4 += allPlayerCharacter.data.currentStickyItem.addThornsToStuckPlayer;
}
num4 += allPlayerCharacter.refs.afflictions.GetTotalThornStatusIncrements();
float num5 = 0.025f * (float)num4;
if (num5 > currentStatus)
{
allPlayerCharacter.refs.afflictions.StatusSFX((STATUSTYPE)9, num5 - currentStatus);
if (allPlayerCharacter.IsLocal && (Object)(object)allPlayerCharacter == (Object)(object)Character.observedCharacter)
{
GUIManager.instance.AddStatusFX((STATUSTYPE)9, num5 - currentStatus);
}
allPlayerCharacter.refs.afflictions.PlayParticle((STATUSTYPE)9);
}
num += num3;
num2 += num4;
}
Character.localCharacter.refs.afflictions.SetStatus((STATUSTYPE)7, 0.025f * (float)num);
Character.localCharacter.refs.afflictions.SetStatus((STATUSTYPE)9, 0.025f * (float)num2);
}
}
public class StaminaSync : MonoBehaviourPun
{
public static StaminaSync Instance;
private void Awake()
{
Instance = this;
}
[PunRPC]
public void RPC_RequestUseStamina(float usage, bool useBonus)
{
if (PhotonNetwork.IsMasterClient)
{
Character.localCharacter.UseStamina(usage, useBonus);
BroadcastStamina();
}
}
[PunRPC]
public void RPC_RequestAddExtraStamina(float add)
{
if (PhotonNetwork.IsMasterClient)
{
Character.localCharacter.AddExtraStamina(add);
BroadcastStamina();
}
}
[PunRPC]
public void RPC_RequestSetExtraStamina(float amt)
{
if (PhotonNetwork.IsMasterClient)
{
Character.localCharacter.SetExtraStamina(amt);
BroadcastStamina();
}
}
[PunRPC]
public void RPC_RequestAddStatus(int statusType, float amt)
{
if (PhotonNetwork.IsMasterClient)
{
Character.localCharacter.refs.afflictions.AddStatus((STATUSTYPE)statusType, amt, false);
BroadcastStatuses();
}
}
[PunRPC]
public void RPC_RequestSubtractStatus(int statusType, float amt)
{
if (PhotonNetwork.IsMasterClient)
{
Character.localCharacter.refs.afflictions.SubtractStatus((STATUSTYPE)statusType, amt, false);
BroadcastStatuses();
}
}
[PunRPC]
public void RPC_RequestSetStatus(int statusType, float amt)
{
if (PhotonNetwork.IsMasterClient)
{
Character.localCharacter.refs.afflictions.SetStatus((STATUSTYPE)statusType, amt);
BroadcastStatuses();
}
}
[PunRPC]
public void RPC_RequestInfiniteStamina(float buffTime)
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Expected O, but got Unknown
if (PhotonNetwork.IsMasterClient)
{
Character.localCharacter.refs.afflictions.AddAffliction((Affliction)new Affliction_InfiniteStamina(buffTime), false);
((MonoBehaviourPun)this).photonView.RPC("RPC_ApplyInfiniteStamina", (RpcTarget)1, new object[1] { buffTime });
}
}
[PunRPC]
public void RPC_ApplyInfiniteStamina(float buffTime)
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
Character.localCharacter.refs.afflictions.AddAffliction((Affliction)new Affliction_InfiniteStamina(buffTime), false);
}
public void BroadcastStamina()
{
Character localCharacter = Character.localCharacter;
((MonoBehaviourPun)this).photonView.RPC("RPC_SyncStamina", (RpcTarget)1, new object[4]
{
localCharacter.data.currentStamina,
localCharacter.data.extraStamina,
localCharacter.data.sinceUseStamina,
localCharacter.infiniteStam
});
}
public void BroadcastStatuses()
{
CharacterAfflictions afflictions = Character.localCharacter.refs.afflictions;
((MonoBehaviourPun)this).photonView.RPC("RPC_SyncStatus", (RpcTarget)1, new object[5] { afflictions.currentStatuses, afflictions.currentIncrementalStatuses, afflictions.currentDecrementalStatuses, afflictions.lastAddedStatus, afflictions.lastAddedIncrementalStatus });
}
[PunRPC]
public void RPC_SyncStamina(float current, float extra, float sinceUse, bool infinite)
{
if ((Object)(object)Character.localCharacter != (Object)null)
{
Character.localCharacter.data.currentStamina = current;
Character.localCharacter.data.extraStamina = extra;
Character.localCharacter.data.sinceUseStamina = sinceUse;
Character.localCharacter.ClampStamina();
GUIManager.instance.bar.ChangeBar();
}
}
[PunRPC]
public void RPC_SyncStatus(float[] current, float[] inc, float[] dec, float[] last, float[] lastInc)
{
if ((Object)(object)Character.localCharacter != (Object)null)
{
CharacterAfflictions afflictions = Character.localCharacter.refs.afflictions;
Array.Copy(current, afflictions.currentStatuses, current.Length);
Array.Copy(inc, afflictions.currentIncrementalStatuses, inc.Length);
Array.Copy(dec, afflictions.currentDecrementalStatuses, dec.Length);
Array.Copy(last, afflictions.lastAddedStatus, last.Length);
Array.Copy(lastInc, afflictions.lastAddedIncrementalStatus, lastInc.Length);
GUIManager.instance.bar.ChangeBar();
}
}
[PunRPC]
public void RPC_SyncConfig(bool StamTogg, float bpMod, float StamRegenMod)
{
StaminaLinked.staminaUseToggle.Value = StamTogg;
StaminaLinked.backpackModifier.Value = bpMod;
StaminaLinked.staminaRegenModifier.Value = StamRegenMod;
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
