using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using HarmonyLib;
using LevelGeneration;
using Player;
using SNetwork;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("StackProMax")]
[assembly: AssemblyProduct("StackProMax")]
[assembly: AssemblyCompany("HawChow")]
[assembly: AssemblyFileVersion("1.0.1.0")]
[assembly: AssemblyInformationalVersion("1.0.1")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = "")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.1.0")]
[module: UnverifiableCode]
namespace HawChow.StackProMax;
internal static class ConfigReloadPolicy
{
internal const int DebounceMilliseconds = 400;
internal static bool ShouldReload(string appliedHash, string diskHash, long lastWriteUtcTicks, long nowUtcTicks, int debounceMilliseconds = 400)
{
if (string.IsNullOrEmpty(diskHash) || string.Equals(appliedHash, diskHash, StringComparison.Ordinal))
{
return false;
}
if (lastWriteUtcTicks <= 0 || nowUtcTicks < lastWriteUtcTicks || debounceMilliseconds < 0)
{
return false;
}
long ticks = TimeSpan.FromMilliseconds(debounceMilliseconds).Ticks;
return nowUtcTicks - lastWriteUtcTicks >= ticks;
}
}
[HarmonyPatch(typeof(LG_PickupItem_Sync), "AttemptInteract")]
internal static class PickupStackPatch
{
[HarmonyPrefix]
private static bool Prefix(LG_PickupItem_Sync __instance, pPickupItemInteraction interaction)
{
//IL_0017: 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_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Invalid comparison between Unknown and I4
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Invalid comparison between Unknown and I4
//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
//IL_0126: Unknown result type (might be due to invalid IL or missing references)
//IL_0131: Unknown result type (might be due to invalid IL or missing references)
//IL_0168: Unknown result type (might be due to invalid IL or missing references)
//IL_016c: Unknown result type (might be due to invalid IL or missing references)
//IL_0176: Unknown result type (might be due to invalid IL or missing references)
//IL_017b: Unknown result type (might be due to invalid IL or missing references)
//IL_0187: Unknown result type (might be due to invalid IL or missing references)
//IL_0188: Unknown result type (might be due to invalid IL or missing references)
//IL_018e: Invalid comparison between Unknown and I4
//IL_0195: Unknown result type (might be due to invalid IL or missing references)
//IL_01ac: Expected I4, but got Unknown
//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
if (!Plugin.IsHost())
{
return true;
}
Plugin.TryReloadConfig();
try
{
if ((Object)(object)__instance == (Object)null || (int)interaction.type != 0)
{
return true;
}
Item item = __instance.item;
if ((Object)(object)item == (Object)null)
{
return true;
}
InventorySlot slot = item.pItemData.slot;
StackKind stackKind = (((int)slot == 4) ? StackKind.ResourcePack : (((int)slot == 5) ? StackKind.Consumable : StackKind.None));
bool value;
switch (stackKind)
{
case StackKind.None:
return true;
default:
value = Plugin.ConsumablesEnabled.Value;
break;
case StackKind.ResourcePack:
value = Plugin.ResourcePacksEnabled.Value;
break;
}
bool flag = value;
if (!flag)
{
return true;
}
int stackLimit = ((stackKind == StackKind.ResourcePack) ? Plugin.ResourcePackStackLimit.Value : Plugin.ConsumableStackLimit.Value);
SNet_Player val = null;
if (!((pPlayer)(ref interaction.pPlayer)).TryGetPlayer(ref val) || (Object)(object)val == (Object)null || !val.HasCharacterSlot)
{
return true;
}
PlayerBackpack val2 = default(PlayerBackpack);
if (!PlayerBackpackManager.TryGetBackpack(val, ref val2) || val2 == null)
{
return true;
}
BackpackItem val3 = default(BackpackItem);
bool flag2 = val2.TryGetBackpackItem(slot, ref val3) && val3 != null && (Object)(object)val3.Instance != (Object)null;
if (!flag2)
{
return true;
}
Item instance = val3.Instance;
bool flag3 = instance.pItemData.itemID_gearCRC == item.pItemData.itemID_gearCRC;
if (!flag3)
{
return true;
}
PlayerAmmoStorage ammoStorage = val2.AmmoStorage;
if (ammoStorage == null)
{
return true;
}
AmmoType val4 = (AmmoType)((stackKind == StackKind.ResourcePack) ? 3 : 5);
float ammoInPack = ammoStorage.GetAmmoInPack(val4);
float ammo = item.pItemData.custom.ammo;
bool isPickupInteraction = (int)interaction.type == 0;
bool featureEnabled = flag;
if (!StackPolicy.TryPlan((int)slot, isHost: true, isPickupInteraction, featureEnabled, flag2, flag3, stackLimit, ammoInPack, ammo, out var plan))
{
return true;
}
pItemData_Custom customData = item.GetCustomData();
return TryApplyPlan(__instance, val2, instance, val, ammoStorage, slot, item.pItemData.itemID_gearCRC, val4, ammoInPack, customData, plan);
}
catch (Exception ex)
{
Plugin.LogWarningOnce("Stack evaluation failed before mutation; vanilla pickup continues: " + ex.GetType().Name + ": " + ex.Message);
return true;
}
}
private static bool TryApplyPlan(LG_PickupItem_Sync sync, PlayerBackpack backpack, Item existingItem, SNet_Player player, PlayerAmmoStorage ammoStorage, InventorySlot inventorySlot, uint itemIdGearCrc, AmmoType ammoType, float originalStoredAmmo, pItemData_Custom originalCustomData, StackPlan plan)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
pItemData_Custom val = originalCustomData;
val.ammo = plan.PickupAmmo;
bool flag = false;
bool flag2 = false;
bool flag3 = false;
try
{
flag = true;
sync.SetCustomData(val, true);
if (plan.RemoveExistingItem)
{
flag2 = true;
PlayerBackpackManager.MasterRemoveItem(existingItem, player);
}
else if (plan.OverflowAmmo > 0f)
{
flag3 = true;
ammoStorage.SetAmmo(ammoType, plan.OverflowAmmo);
}
return true;
}
catch (Exception ex)
{
bool flag4 = true;
if (flag3)
{
try
{
ammoStorage.SetAmmo(ammoType, originalStoredAmmo);
}
catch
{
flag4 = false;
}
}
if (flag2)
{
try
{
BackpackItem val2 = default(BackpackItem);
if (!backpack.TryGetBackpackItem(inventorySlot, itemIdGearCrc, ref val2) || val2 == null || !((Object)(object)val2.Instance != (Object)null))
{
PlayerBackpackManager.MasterAddItem(existingItem, player);
}
}
catch
{
flag4 = false;
}
}
if (flag)
{
try
{
sync.SetCustomData(originalCustomData, true);
}
catch
{
flag4 = false;
}
}
Plugin.LogWarningOnce("Stack transaction failed; vanilla pickup cancelled and rollbackComplete=" + flag4 + " (" + ex.GetType().Name + ": " + ex.Message + ").");
return false;
}
}
}
[BepInPlugin("HawChow.StackProMax", "StackProMax", "1.0.1")]
public sealed class Plugin : BasePlugin
{
internal static ManualLogSource PluginLog;
internal static ConfigEntry<bool> ResourcePacksEnabled;
internal static ConfigEntry<int> ResourcePackStackLimit;
internal static ConfigEntry<bool> ConsumablesEnabled;
internal static ConfigEntry<int> ConsumableStackLimit;
private static ConfigFile _configFile;
private static string _appliedConfigHash;
private static bool _masterReadWarningLogged;
private static bool _stackErrorLogged;
public override void Load()
{
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Expected O, but got Unknown
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
//IL_00bb: Expected O, but got Unknown
//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
//IL_00f2: Expected O, but got Unknown
//IL_0149: Unknown result type (might be due to invalid IL or missing references)
//IL_0150: Expected O, but got Unknown
PluginLog = ((BasePlugin)this).Log;
_configFile = ((BasePlugin)this).Config;
ResourcePacksEnabled = ((BasePlugin)this).Config.Bind<bool>("ResourcePacks", "Enabled", true, "Allow the host to merge pickups into the matching resource-pack stack.");
ResourcePackStackLimit = ((BasePlugin)this).Config.Bind<int>("ResourcePacks", "MaxStackCount", 6, new ConfigDescription("Maximum full resource-pack units in one stack. Six units correspond to 120 normalized resource-pack ammo units.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 999), Array.Empty<object>()));
ConsumablesEnabled = ((BasePlugin)this).Config.Bind<bool>("Consumables", "Enabled", true, "Allow the host to merge pickups into the matching consumable stack.");
ConsumableStackLimit = ((BasePlugin)this).Config.Bind<int>("Consumables", "MaxStackCount", 6, new ConfigDescription("Maximum consumable ammo units in one matching stack.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 999), Array.Empty<object>()));
((BasePlugin)this).Config.Save();
_appliedConfigHash = (TryHashConfig(out var _, out var _) ? HashConfigFile() : string.Empty);
Harmony val = new Harmony("HawChow.StackProMax");
val.PatchAll(typeof(Plugin).Assembly);
MethodBase methodBase = AccessTools.Method(typeof(LG_PickupItem_Sync), "AttemptInteract", (Type[])null, (Type[])null);
if (methodBase == null || !HasOwnPatch(val, methodBase))
{
throw new InvalidOperationException("Required host pickup stacking patch was not installed.");
}
ManualLogSource log = ((BasePlugin)this).Log;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(176, 6, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("StackProMax");
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("1.0.1");
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" loaded; host-authoritative pickup stacking active; ");
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("resource packs=");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<bool>(ResourcePacksEnabled.Value);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(", limit=");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(ResourcePackStackLimit.Value);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("; ");
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("consumables=");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<bool>(ConsumablesEnabled.Value);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(", limit=");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(ConsumableStackLimit.Value);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("; ");
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("config hot reload checks the stable cfg before each host pickup interaction.");
}
log.LogInfo(val2);
}
internal static bool IsHost()
{
try
{
return SNet.IsMaster;
}
catch (Exception ex)
{
if (!_masterReadWarningLogged)
{
_masterReadWarningLogged = true;
ManualLogSource pluginLog = PluginLog;
if (pluginLog != null)
{
pluginLog.LogWarning((object)("SNet.IsMaster could not be read; stacking remains disabled on this peer: " + ex.Message));
}
}
return false;
}
}
internal static void TryReloadConfig()
{
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Expected O, but got Unknown
if (_configFile == null)
{
return;
}
try
{
if (!TryHashConfig(out var hash, out var lastWriteUtcTicks))
{
return;
}
long ticks = DateTime.UtcNow.Ticks;
if (!ConfigReloadPolicy.ShouldReload(_appliedConfigHash, hash, lastWriteUtcTicks, ticks))
{
return;
}
_configFile.Reload();
_appliedConfigHash = HashConfigFile();
ManualLogSource pluginLog = PluginLog;
if (pluginLog != null)
{
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(53, 4, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Config hot-reloaded: resource packs=");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<bool>(ResourcePacksEnabled.Value);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("/");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(ResourcePackStackLimit.Value);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("; ");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("consumables=");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<bool>(ConsumablesEnabled.Value);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("/");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(ConsumableStackLimit.Value);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".");
}
pluginLog.LogInfo(val);
}
}
catch (Exception ex)
{
ManualLogSource pluginLog2 = PluginLog;
if (pluginLog2 != null)
{
pluginLog2.LogWarning((object)("Config hot reload failed; previous values remain in use: " + ex.Message));
}
}
}
internal static void LogWarningOnce(string message)
{
if (!_stackErrorLogged)
{
_stackErrorLogged = true;
ManualLogSource pluginLog = PluginLog;
if (pluginLog != null)
{
pluginLog.LogWarning((object)message);
}
}
}
private static bool HasOwnPatch(Harmony harmony, MethodBase target)
{
foreach (MethodBase patchedMethod in harmony.GetPatchedMethods())
{
if (patchedMethod == target)
{
return true;
}
}
return false;
}
private static bool TryHashConfig(out string hash, out long lastWriteUtcTicks)
{
hash = string.Empty;
lastWriteUtcTicks = 0L;
string text = ((_configFile == null) ? string.Empty : _configFile.ConfigFilePath);
if (string.IsNullOrWhiteSpace(text) || !File.Exists(text))
{
return false;
}
FileInfo fileInfo = new FileInfo(text);
fileInfo.Refresh();
byte[] array = File.ReadAllBytes(text);
FileInfo fileInfo2 = new FileInfo(text);
fileInfo2.Refresh();
if (!fileInfo2.Exists || fileInfo.Length != fileInfo2.Length || fileInfo.LastWriteTimeUtc.Ticks != fileInfo2.LastWriteTimeUtc.Ticks || array.Length != fileInfo2.Length)
{
return false;
}
hash = Convert.ToHexString(SHA256.HashData(array));
lastWriteUtcTicks = fileInfo2.LastWriteTimeUtc.Ticks;
return true;
}
private static string HashConfigFile()
{
if (!TryHashConfig(out var hash, out var _))
{
return string.Empty;
}
return hash;
}
}
internal static class PluginInfo
{
internal const string Guid = "HawChow.StackProMax";
internal const string Name = "StackProMax";
internal const string Version = "1.0.1";
}
internal enum StackKind
{
None,
ResourcePack,
Consumable
}
internal readonly struct StackPlan
{
internal StackKind Kind { get; }
internal float Capacity { get; }
internal float PickupAmmo { get; }
internal float OverflowAmmo { get; }
internal bool RemoveExistingItem { get; }
internal StackPlan(StackKind kind, float capacity, float pickupAmmo, float overflowAmmo, bool removeExistingItem)
{
Kind = kind;
Capacity = capacity;
PickupAmmo = pickupAmmo;
OverflowAmmo = overflowAmmo;
RemoveExistingItem = removeExistingItem;
}
}
internal static class StackPolicy
{
internal const int ResourcePackSlot = 4;
internal const int ConsumableSlot = 5;
internal const int DefaultStackLimit = 6;
internal const int MaximumStackLimit = 999;
internal const float ResourcePackAmmoPerStack = 20f;
internal static StackKind KindForSlot(int slot)
{
return slot switch
{
4 => StackKind.ResourcePack,
5 => StackKind.Consumable,
_ => StackKind.None,
};
}
internal static float CapacityFor(StackKind kind, int stackLimit)
{
if (stackLimit < 1 || stackLimit > 999)
{
return 0f;
}
return kind switch
{
StackKind.ResourcePack => (float)stackLimit * 20f,
StackKind.Consumable => stackLimit,
_ => 0f,
};
}
internal static bool TryPlan(int slot, bool isHost, bool isPickupInteraction, bool featureEnabled, bool hasBackpackItem, bool itemIdsMatch, int stackLimit, float storedAmmo, float incomingAmmo, out StackPlan plan)
{
plan = default(StackPlan);
StackKind stackKind = KindForSlot(slot);
if (stackKind == StackKind.None || !isHost || !isPickupInteraction || !featureEnabled || !hasBackpackItem || !itemIdsMatch || !float.IsFinite(storedAmmo) || !float.IsFinite(incomingAmmo) || storedAmmo < 0f || incomingAmmo <= 0f)
{
return false;
}
float num = CapacityFor(stackKind, stackLimit);
if (num <= 0f || storedAmmo >= num)
{
return false;
}
float num2 = storedAmmo + incomingAmmo;
if (!float.IsFinite(num2) || num2 <= storedAmmo)
{
return false;
}
if (num2 <= num)
{
plan = new StackPlan(stackKind, num, num2, 0f, removeExistingItem: true);
return true;
}
plan = new StackPlan(stackKind, num, num, num2 - num, removeExistingItem: false);
return true;
}
}
