using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using UnityEngine;
using Zorro.Core;
using Zorro.Core.Serizalization;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[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 SimpleTweaks
{
[HarmonyPatch(typeof(CharacterAnimations), "PlayEmote")]
internal static class Patch_BackflipAlwaysSucceed
{
private const string BackflipEmote = "A_Scout_Emote_BackFlip";
private static readonly FieldInfo CharacterField = AccessTools.Field(typeof(CharacterAnimations), "character");
private static bool Prefix(CharacterAnimations __instance, string emoteName)
{
if (!Plugin.cfgEnableBackflipAlwaysSucceed.Value)
{
return true;
}
if (emoteName != "A_Scout_Emote_BackFlip")
{
return true;
}
if (CharacterField == null)
{
return true;
}
object? value = CharacterField.GetValue(__instance);
Character val = (Character)((value is Character) ? value : null);
if (val == null)
{
return true;
}
if (val.refs == null || (Object)(object)val.refs.view == (Object)null)
{
return true;
}
val.refs.view.RPC("RPCA_PlayRemove", (RpcTarget)0, new object[2] { emoteName, false });
return false;
}
}
internal static class PendingClientSwap
{
public static bool Active;
public static byte HandSlotID;
public static byte BackpackSlotID;
public static BackpackReference BackpackRef;
public static float RequestTime;
private const float TimeoutSeconds = 3f;
public static void Set(byte handSlotID, byte backpackSlotID, BackpackReference bpRef)
{
//IL_0012: 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)
Active = true;
HandSlotID = handSlotID;
BackpackSlotID = backpackSlotID;
BackpackRef = bpRef;
RequestTime = Time.time;
}
public static void Clear()
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
Active = false;
BackpackRef = default(BackpackReference);
}
public static bool IsValid()
{
if (!Active)
{
return false;
}
if (Time.time - RequestTime > 3f)
{
Clear();
return false;
}
if (!((BackpackReference)(ref BackpackRef)).exists)
{
Clear();
return false;
}
return true;
}
}
internal static class BackpackSwapLogic
{
private static readonly FieldInfo VisualItemsField = AccessTools.Field(typeof(BackpackVisuals), "visualItems");
public static void DoSwapLogic(Character character, byte handSlotID, BackpackReference bpRef, byte bpSlotID)
{
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
if (!PhotonNetwork.IsMasterClient)
{
return;
}
ItemSlot itemSlot = character.player.GetItemSlot(handSlotID);
BackpackData data = ((BackpackReference)(ref bpRef)).GetData();
if (itemSlot != null && data != null)
{
ItemSlot val = data.itemSlots[bpSlotID];
if (val != null)
{
Item prefab = itemSlot.prefab;
ItemInstanceData data2 = itemSlot.data;
Item prefab2 = val.prefab;
ItemInstanceData data3 = val.data;
val.SetItem(prefab, data2);
itemSlot.SetItem(prefab2, data3);
ClearBackpackVisualSlot(bpRef, bpSlotID);
SyncInventory(character);
SyncBackpack(bpRef);
((BackpackReference)(ref bpRef)).GetVisuals().RefreshVisuals();
}
}
}
private static void ClearBackpackVisualSlot(BackpackReference bpRef, byte slotID)
{
BackpackVisuals visuals = ((BackpackReference)(ref bpRef)).GetVisuals();
if ((Object)(object)visuals == (Object)null)
{
return;
}
if (visuals.spawnedVisualItems.TryGetValue(slotID, out var value))
{
if ((Object)(object)value != (Object)null)
{
PhotonNetwork.Destroy(((Component)value).gameObject);
}
visuals.spawnedVisualItems.Remove(slotID);
}
if (VisualItemsField != null)
{
object value2 = VisualItemsField.GetValue(visuals);
value2?.GetType().GetMethod("Remove", new Type[1] { typeof(byte) })?.Invoke(value2, new object[1] { slotID });
}
}
private static void SyncInventory(Character character)
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
byte[] array = IBinarySerializable.ToManagedArray<InventorySyncData>(new InventorySyncData(character.player.itemSlots, character.player.backpackSlot, character.player.tempFullSlot));
((MonoBehaviourPun)character.player).photonView.RPC("SyncInventoryRPC", (RpcTarget)1, new object[2] { array, false });
}
private static void SyncBackpack(BackpackReference bpRef)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
if ((int)bpRef.type == 0)
{
bpRef.view.RPC("SetItemInstanceDataRPC", (RpcTarget)1, new object[1] { ((BackpackReference)(ref bpRef)).GetItemInstanceData() });
}
}
public static void RefreshHandVisual(Character character, byte handSlotID)
{
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
if (!character.IsLocal)
{
return;
}
CharacterItems val = character.refs?.items;
if (!((Object)(object)val == (Object)null))
{
if (handSlotID == 250)
{
((MonoBehaviourPun)val).photonView.RPC("DestroyHeldItemRpc", (RpcTarget)0, Array.Empty<object>());
val.EquipSlot(Optionable<byte>.Some(handSlotID));
}
else
{
val.EquipSlot(Optionable<byte>.Some(handSlotID));
}
}
}
}
[HarmonyPatch(typeof(Item), "Interact")]
internal static class BackpackSwapPatch
{
private static bool Prefix(Item __instance, Character interactor)
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Invalid comparison between Unknown and I4
//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
//IL_013b: Unknown result type (might be due to invalid IL or missing references)
PendingClientSwap.Clear();
if (!Plugin.cfgEnableBackpackSwap.Value)
{
return true;
}
if ((int)__instance.itemState != 2)
{
return true;
}
if (!__instance.backpackReference.IsSome)
{
return true;
}
if ((Object)(object)interactor.data.currentItem == (Object)null)
{
return true;
}
if (interactor.refs.items.lastEquippedSlotTime + 0.25f > Time.time)
{
return false;
}
if (!interactor.refs.items.currentSelectedSlot.IsSome)
{
return true;
}
byte value = interactor.refs.items.currentSelectedSlot.Value;
if ((Object)(object)interactor.data.currentItem != (Object)null && !interactor.data.currentItem.UIData.canPocket)
{
return true;
}
if (interactor.data.isClimbing && !__instance.UIData.canPocket)
{
return true;
}
var (b, bpRef) = __instance.backpackReference.Value;
if (PhotonNetwork.IsMasterClient)
{
BackpackSwapLogic.DoSwapLogic(interactor, value, bpRef, b);
BackpackSwapLogic.RefreshHandVisual(interactor, value);
((Component)__instance).gameObject.SetActive(false);
return false;
}
if (!interactor.player.HasEmptySlot(__instance.itemID))
{
return true;
}
if (interactor.data.isClimbingAnything)
{
return true;
}
PendingClientSwap.Set(value, b, bpRef);
return true;
}
}
[HarmonyPatch(typeof(CharacterItems), "OnPickupAccepted")]
internal static class BackpackSwapCompletePatch
{
private static void Prefix(CharacterItems __instance, byte slotID)
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: 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_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
if (!PendingClientSwap.IsValid())
{
return;
}
byte handSlotID = PendingClientSwap.HandSlotID;
byte backpackSlotID = PendingClientSwap.BackpackSlotID;
BackpackReference backpackRef = PendingClientSwap.BackpackRef;
PendingClientSwap.Clear();
if (slotID == handSlotID)
{
return;
}
Character component = ((Component)__instance).GetComponent<Character>();
if ((Object)(object)component == (Object)null || !component.IsLocal)
{
return;
}
ItemSlot itemSlot = component.player.GetItemSlot(handSlotID);
if (itemSlot != null && !itemSlot.IsEmpty())
{
if ((int)backpackRef.type == 0)
{
backpackRef.view.RPC("RPCAddItemToBackpack", (RpcTarget)0, new object[3]
{
((MonoBehaviourPun)component.player).photonView,
handSlotID,
backpackSlotID
});
}
else
{
backpackRef.view.RPC("RPCAddItemToCharacterBackpack", (RpcTarget)0, new object[3]
{
((MonoBehaviourPun)component.player).photonView,
handSlotID,
backpackSlotID
});
}
component.player.EmptySlot(Optionable<byte>.Some(handSlotID));
}
}
}
[HarmonyPatch(typeof(Character), "UpdateVariablesFixed")]
internal static class Patch_DeathRegeneration
{
private static void Postfix(Character __instance)
{
if (!Plugin.cfgEnableDeathRegeneration.Value || !((MonoBehaviourPun)__instance).photonView.IsMine)
{
return;
}
CharacterData data = __instance.data;
if (!((Object)(object)data == (Object)null) && data.fullyPassedOut && !((Object)(object)data.carrier == (Object)null) && !__instance.refs.afflictions.willZombify && !__instance.input.interactIsPressed)
{
float num = Mathf.Max(0f, Plugin.cfgDeathRegenerationRate.Value);
if (!(num <= 0f))
{
data.deathTimer = Mathf.Max(0f, data.deathTimer - num * Time.fixedDeltaTime / 60f);
}
}
}
}
internal static class HungerOverflowState
{
private static readonly FieldInfo IncrementalField = AccessTools.Field(typeof(CharacterAfflictions), "currentIncrementalStatuses");
private static float _capturedHunger = 0f;
public static Character GetConsumer(ItemActionBase action)
{
if ((Object)(object)action == (Object)null)
{
return null;
}
Item component = ((Component)action).GetComponent<Item>();
if (!((Object)(object)component != (Object)null))
{
return null;
}
return component.holderCharacter;
}
public static void CaptureBefore(Character character)
{
_capturedHunger = 0f;
if (!((Object)(object)character == (Object)null) && character.IsLocal)
{
CharacterAfflictions val = character.refs?.afflictions;
if (!((Object)(object)val == (Object)null))
{
_capturedHunger = Mathf.Max(0f, val.GetCurrentStatus((STATUSTYPE)1));
}
}
}
public static void Apply(Character character, float restoreAmount)
{
if ((Object)(object)character == (Object)null || !character.IsLocal)
{
return;
}
float capturedHunger = _capturedHunger;
_capturedHunger = 0f;
if (restoreAmount <= 0f)
{
return;
}
float num = Mathf.Max(0f, restoreAmount - capturedHunger);
if (num <= 0f)
{
return;
}
CharacterAfflictions val = character.refs?.afflictions;
if ((Object)(object)val == (Object)null)
{
return;
}
float num2 = val.hungerPerSecond * Ascents.hungerRateMultiplier;
if (num2 <= 0f)
{
return;
}
float num3 = Mathf.Max(0f, Plugin.cfgHungerOverflowSecondsPerPoint.Value);
float num4 = num * 100f * num3;
float num5 = num4 * num2;
if (!(IncrementalField == null) && IncrementalField.GetValue(val) is float[] array && array.Length > 1)
{
array[1] = Mathf.Min(array[1], 0f);
float value = Plugin.cfgHungerOverflowMaxSeconds.Value;
if (value > 0f)
{
float num6 = 0.025f - value * num2;
array[1] = Mathf.Max(array[1] - num5, num6);
}
else
{
array[1] -= num5;
}
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogDebug((object)$"[饥饿溢出] 溢出 {num * 100f:0.#} 点（恢复 {restoreAmount * 100f:0.#}，已有 {capturedHunger * 100f:0.#}）→ 倒计时延长 {num4:0.#} 秒");
}
}
}
}
[HarmonyPatch(typeof(Action_RestoreHunger), "RunAction")]
internal static class Patch_ActionRestoreHunger_Overflow
{
private static void Prefix(Action_RestoreHunger __instance)
{
if (Plugin.cfgEnableHungerOverflow.Value)
{
HungerOverflowState.CaptureBefore(HungerOverflowState.GetConsumer((ItemActionBase)(object)__instance));
}
}
private static void Postfix(Action_RestoreHunger __instance)
{
if (Plugin.cfgEnableHungerOverflow.Value)
{
HungerOverflowState.Apply(HungerOverflowState.GetConsumer((ItemActionBase)(object)__instance), __instance.restorationAmount);
}
}
}
[HarmonyPatch(typeof(Action_ModifyStatus), "RunAction")]
internal static class Patch_ActionModifyStatus_Overflow
{
private static readonly FieldInfo IfSkeletonField = AccessTools.Field(typeof(Action_ModifyStatus), "ifSkeleton");
private static void Prefix(Action_ModifyStatus __instance, ref bool __state)
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Invalid comparison between Unknown and I4
__state = false;
if (!Plugin.cfgEnableHungerOverflow.Value)
{
__state = true;
}
else if ((int)__instance.statusType != 1 || __instance.changeAmount >= 0f)
{
__state = true;
}
else if (IfSkeletonField != null && (bool)IfSkeletonField.GetValue(__instance))
{
__state = true;
}
else
{
HungerOverflowState.CaptureBefore(HungerOverflowState.GetConsumer((ItemActionBase)(object)__instance));
}
}
private static void Postfix(Action_ModifyStatus __instance, bool __state)
{
if (!__state)
{
HungerOverflowState.Apply(HungerOverflowState.GetConsumer((ItemActionBase)(object)__instance), Mathf.Abs(__instance.changeAmount));
}
}
}
internal static class PeakStatsExCompat
{
private const string PeakStatsExTypeName = "PeakStatsEx.StaminaInfoPatch";
private static readonly FieldInfo IncrementalField = AccessTools.Field(typeof(CharacterAfflictions), "currentIncrementalStatuses");
public static void Apply(Harmony harmony)
{
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: Expected O, but got Unknown
Type type = AccessTools.TypeByName("PeakStatsEx.StaminaInfoPatch");
if (type == null)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogInfo((object)"PeakStatsEx 未加载，跳过饥饿倒计时显示兼容补丁。");
}
return;
}
MethodInfo methodInfo = AccessTools.Method(type, "GetHungerIncrementalStatus", (Type[])null, (Type[])null);
if (methodInfo == null)
{
ManualLogSource log2 = Plugin.Log;
if (log2 != null)
{
log2.LogWarning((object)"PeakStatsEx 已加载，但未找到 GetHungerIncrementalStatus，跳过兼容补丁。");
}
return;
}
MethodInfo methodInfo2 = AccessTools.Method(typeof(PeakStatsExCompat), "PostfixNegativeIncremental", (Type[])null, (Type[])null);
harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
ManualLogSource log3 = Plugin.Log;
if (log3 != null)
{
log3.LogInfo((object)"已应用 PeakStatsEx 饥饿倒计时显示兼容补丁。");
}
}
private static void PostfixNegativeIncremental(CharacterAfflictions afflictions, ref float __result)
{
if (!((Object)(object)afflictions == (Object)null) && !(IncrementalField == null) && IncrementalField.GetValue(afflictions) is float[] array && array.Length > 1)
{
float num = array[1];
if (num < 0f)
{
__result = num;
}
}
}
}
[BepInPlugin("com.simpletweaks.peak", "SimpleTweaks", "1.1.0")]
[BepInProcess("PEAK.exe")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class Plugin : BaseUnityPlugin
{
internal static ConfigEntry<bool> cfgEnableHungerOverflow;
internal static ConfigEntry<float> cfgHungerOverflowSecondsPerPoint;
internal static ConfigEntry<float> cfgHungerOverflowMaxSeconds;
internal static ConfigEntry<bool> cfgEnableBackpackSwap;
internal static ConfigEntry<bool> cfgEnableBackflipAlwaysSucceed;
internal static ConfigEntry<bool> cfgEnableDeathRegeneration;
internal static ConfigEntry<float> cfgDeathRegenerationRate;
internal static ManualLogSource Log;
private void Awake()
{
//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
//IL_0101: Unknown result type (might be due to invalid IL or missing references)
//IL_010c: Expected O, but got Unknown
Log = ((BaseUnityPlugin)this).Logger;
cfgEnableHungerOverflow = ((BaseUnityPlugin)this).Config.Bind<bool>("Hunger", "EnableHungerOverflow", true, "饥饿溢出延长计时开关。吃食物时，超过当前饥饿值的恢复量会按比例延长下一次变饿的倒计时。");
cfgHungerOverflowSecondsPerPoint = ((BaseUnityPlugin)this).Config.Bind<float>("Hunger", "HungerOverflowSecondsPerPoint", 10f, "每溢出 1 点饥饿值（1%）延长饥饿倒计时的秒数。默认 10 秒。");
cfgHungerOverflowMaxSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Hunger", "HungerOverflowMaxSeconds", 120f, "饥饿倒计时延长后的上限（秒）。无论溢出多少，倒计时都不会超过此值，默认 120 秒（2 分钟）。0 表示不限制。");
cfgEnableBackpackSwap = ((BaseUnityPlugin)this).Config.Bind<bool>("Backpack", "EnableBackpackSwap", true, "背包物品替换开关。手上已有物品时点击背包中物品，会将手中物品与背包物品互换位置。");
cfgEnableBackflipAlwaysSucceed = ((BaseUnityPlugin)this).Config.Bind<bool>("Emote", "EnableBackflipAlwaysSucceed", true, "后空翻 100% 成功开关。原版后空翻有 50% 概率失败倒地，开启后必定成功落地。");
cfgEnableDeathRegeneration = ((BaseUnityPlugin)this).Config.Bind<bool>("Death", "EnableDeathRegeneration", true, "死亡计时回复开关。本地玩家被其他玩家背着时，死亡计时（昏迷倒计时）会缓慢回复。");
cfgDeathRegenerationRate = ((BaseUnityPlugin)this).Config.Bind<float>("Death", "DeathRegenerationRate", 1f, "死亡计时回复速率（相对原版消耗速率）。1.0 = 与消耗同速回复（默认）；0.5 = 回复速度是消耗速度的一半。0 或负数表示不回复。");
Harmony val = new Harmony("com.simpletweaks.peak");
val.PatchAll();
PeakStatsExCompat.Apply(val);
Log.LogInfo((object)"SimpleTweaks v1.1.0 已加载");
}
}
internal static class PluginInfo
{
public const string PLUGIN_GUID = "com.simpletweaks.peak";
public const string PLUGIN_NAME = "SimpleTweaks";
public const string PLUGIN_VERSION = "1.1.0";
}
}
