using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Valheim Item Vacuum")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Valheim Item Vacuum")]
[assembly: AssemblyCopyright("Copyright © 2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("a0ea8960-687f-4860-821c-01a3e40c5dd8")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace MasterVacuumMod;
[BepInPlugin("com.peep.mastervacuum", "Item Vacuum", "1.1.3")]
public class MasterVacuumPlugin : BaseUnityPlugin
{
[HarmonyPatch(typeof(ZNet), "Awake")]
private static class ZNet_Awake_Patch
{
private static void Postfix(ZNet __instance)
{
ZRoutedRpc.instance.Register<long, uint, ZPackage>("MasterVacuum_ConfirmRemoval", (Action<long, long, uint, ZPackage>)Instance.RPC_MasterVacuum_ConfirmRemoval);
}
}
[HarmonyPatch(typeof(Terminal), "InitTerminal")]
private static class ConsolePatch
{
[Serializable]
[CompilerGenerated]
private sealed class <>c
{
public static readonly <>c <>9 = new <>c();
public static Func<string, bool> <>9__0_1;
public static ConsoleEvent <>9__0_0;
internal void <Postfix>b__0_0(ConsoleEventArgs args)
{
string text = ZoneSystem.instance.m_globalKeysValues.Keys.FirstOrDefault((string k) => k.StartsWith("mastervacuum_zdoid"));
if (!string.IsNullOrEmpty(text))
{
ZoneSystem.instance.RemoveGlobalKey(text);
args.Context.AddString("Master Vacuum key cleared.");
}
else
{
args.Context.AddString("No vacuum key found.");
}
}
internal bool <Postfix>b__0_1(string k)
{
return k.StartsWith("mastervacuum_zdoid");
}
}
private static void Postfix(Terminal __instance)
{
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: 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_0029: Expected O, but got Unknown
object obj = <>c.<>9__0_0;
if (obj == null)
{
ConsoleEvent val = delegate(ConsoleEventArgs args)
{
string text = ZoneSystem.instance.m_globalKeysValues.Keys.FirstOrDefault((string k) => k.StartsWith("mastervacuum_zdoid"));
if (!string.IsNullOrEmpty(text))
{
ZoneSystem.instance.RemoveGlobalKey(text);
args.Context.AddString("Master Vacuum key cleared.");
}
else
{
args.Context.AddString("No vacuum key found.");
}
};
<>c.<>9__0_0 = val;
obj = (object)val;
}
new ConsoleCommand("resetvacuum", "Manual wipe of the vacuum global key.", (ConsoleEvent)obj, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
}
}
[HarmonyPatch(typeof(Container), "Awake")]
private static class Container_Track_Patch
{
private static void Postfix(Container __instance)
{
//IL_0144: Unknown result type (might be due to invalid IL or missing references)
//IL_0149: Unknown result type (might be due to invalid IL or missing references)
ZNetView nview = Traverse.Create((object)__instance).Field("m_nview").GetValue<ZNetView>();
if ((Object)(object)nview == (Object)null || !nview.IsValid())
{
return;
}
nview.Register("OnInventoryChanged", (Action<long>)delegate
{
});
nview.Register<long, uint, ZPackage>("MasterVacuum_RequestAdd", (Action<long, long, uint, ZPackage>)delegate(long sender, long vacUserId, uint vacId, ZPackage pkg)
{
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: 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_0051: Expected O, but got Unknown
//IL_00a3: 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_00ad: 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_00f6: Unknown result type (might be due to invalid IL or missing references)
//IL_00fd: Expected O, but got Unknown
if (nview.IsOwner())
{
Inventory inventory3 = __instance.GetInventory();
Inventory val2 = new Inventory("temp", (Sprite)null, inventory3.GetWidth(), inventory3.GetHeight());
val2.Load(pkg);
Inventory val3 = new Inventory("success", (Sprite)null, inventory3.GetWidth(), inventory3.GetHeight());
bool flag = false;
foreach (ItemData allItem in val2.GetAllItems())
{
if (inventory3.CanAddItem(allItem, -1))
{
inventory3.AddItem(allItem);
val3.AddItem(allItem.Clone());
flag = true;
}
else
{
ItemDrop.DropItem(allItem, allItem.m_stack, ((Component)__instance).transform.position + Vector3.up, Quaternion.identity);
}
}
if (flag)
{
nview.InvokeRPC(ZNetView.Everybody, "OnInventoryChanged", Array.Empty<object>());
if (vacUserId != 0L)
{
ZPackage val4 = new ZPackage();
val3.Save(val4);
ZRoutedRpc.instance.InvokeRoutedRPC(sender, "MasterVacuum_ConfirmRemoval", new object[3] { vacUserId, vacId, val4 });
}
}
}
});
nview.Register<ZPackage>("MasterVacuum_RequestRemove", (Action<long, ZPackage>)delegate(long uid, ZPackage pkg)
{
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
if (!nview.IsOwner())
{
return;
}
Inventory inventory2 = __instance.GetInventory();
Inventory val = new Inventory("temp", (Sprite)null, inventory2.GetWidth(), inventory2.GetHeight());
val.Load(pkg);
foreach (ItemData allItem2 in val.GetAllItems())
{
inventory2.RemoveItem(allItem2.m_shared.m_name, allItem2.m_stack, -1, true);
}
});
if (!TrackedContainers.Contains(__instance))
{
TrackedContainers.Add(__instance);
}
Inventory inventory = __instance.GetInventory();
nview.GetZDO().Set(HashWidth, inventory.GetWidth(), false);
nview.GetZDO().Set(HashHeight, inventory.GetHeight(), false);
if (((Object)__instance).name.Contains("Item_Vacuum") && ZNet.instance.IsServer())
{
ZDOID uid2 = nview.GetZDO().m_uid;
ZoneSystem.instance.SetGlobalKey(string.Format("{0}={1}:{2}", "mastervacuum_zdoid", ((ZDOID)(ref uid2)).UserID, ((ZDOID)(ref uid2)).ID));
}
}
}
[HarmonyPatch(typeof(ZoneSystem), "Start")]
private static class ZoneSystem_Start_Persistent_Patch
{
private static void Postfix()
{
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
if (ZNet.instance.IsServer() && !ZoneSystem.instance.m_globalKeysValues.Keys.Any((string k) => k.StartsWith("mastervacuum_zdoid=")))
{
logger.LogInfo((object)"Server started: No Master Vacuum link found. Scanning world database...");
string text = "Item_Vacuum";
List<ZDO> list = new List<ZDO>();
int num = 0;
while (!ZDOMan.instance.GetAllZDOsWithPrefabIterative(text, list, ref num))
{
}
if (list.Count > 0)
{
ZDOID uid = list[0].m_uid;
string globalKey = $"mastervacuum_zdoid={((ZDOID)(ref uid)).UserID}:{((ZDOID)(ref uid)).ID}";
ZoneSystem.instance.SetGlobalKey(globalKey);
logger.LogInfo((object)$"Successfully restored Master Vacuum Link: {((ZDOID)(ref uid)).UserID}:{((ZDOID)(ref uid)).ID}");
}
else
{
logger.LogInfo((object)"No Master Vacuum objects found in the world.");
}
}
}
}
[HarmonyPatch(typeof(Container), "OnDestroyed")]
private static class Container_Cleanup_Patch
{
private static void Prefix(Container __instance)
{
TrackedContainers.RemoveAll((Container c) => (Object)(object)c == (Object)null);
if (((Object)__instance).name.Contains("Item_Vacuum") && ZNet.instance.IsServer())
{
string text = ZoneSystem.instance.m_globalKeysValues.Keys.FirstOrDefault((string k) => k.StartsWith("mastervacuum_zdoid"));
if (!string.IsNullOrEmpty(text))
{
ZoneSystem.instance.RemoveGlobalKey(text);
}
}
}
}
[HarmonyPatch(typeof(ItemDrop), "SlowUpdate")]
private static class ItemDrop_SlowUpdate_Patch
{
private static Dictionary<ZDOID, float> m_attemptTracker = new Dictionary<ZDOID, float>();
private static void Postfix(ItemDrop __instance, ZNetView ___m_nview)
{
//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_0032: 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_00af: Unknown result type (might be due to invalid IL or missing references)
//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
//IL_00e8: Expected O, but got Unknown
//IL_010b: Unknown result type (might be due to invalid IL or missing references)
//IL_011a: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)___m_nview == (Object)null || !___m_nview.IsValid() || !___m_nview.IsOwner())
{
return;
}
ZDOID uid = ___m_nview.GetZDO().m_uid;
float time = Time.time;
if ((!m_attemptTracker.TryGetValue(uid, out var value) || !(time - value < 10f)) && IsItemTypeAllowed(__instance.m_itemData.m_shared.m_itemType))
{
string text = ZoneSystem.instance.m_globalKeysValues.Keys.FirstOrDefault((string k) => k.StartsWith("mastervacuum_zdoid"));
if (!string.IsNullOrEmpty(text))
{
ZDOID val = ParseZDOID(text.Split(new char[1] { '=' })[1]);
m_attemptTracker[uid] = time;
Inventory val2 = new Inventory("temp", (Sprite)null, 1, 1);
val2.AddItem(__instance.m_itemData.Clone());
ZPackage val3 = new ZPackage();
val2.Save(val3);
ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "MasterVacuum_RequestIntake", new object[3] { val, val3, uid });
}
}
}
}
[HarmonyPatch(typeof(Player), "UpdatePlacement")]
private static class Placement_Blocker_Patch
{
private static bool Prefix(Player __instance)
{
//IL_008a: 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_0095: Unknown result type (might be due to invalid IL or missing references)
GameObject value = Traverse.Create((object)__instance).Field("m_placementGhost").GetValue<GameObject>();
if ((Object)(object)value == (Object)null || !((Object)value).name.Contains("Item_Vacuum"))
{
return true;
}
string text = ZoneSystem.instance.m_globalKeysValues.Keys.FirstOrDefault((string k) => k.StartsWith("mastervacuum_zdoid"));
if (!string.IsNullOrEmpty(text))
{
string[] array = text.Split(new char[1] { '=' });
if (array.Length >= 2)
{
ZDOID val = ParseZDOID(array[1]);
if (ZDOMan.instance.GetZDO(val) == null)
{
ZoneSystem.instance.RemoveGlobalKey(text);
return true;
}
}
SetPlacementGhostValidDelegate?.Invoke(__instance, arg2: false);
if (ZInput.GetButtonDown("Attack") || ZInput.GetButton("Attack"))
{
((Character)__instance).Message((MessageType)2, "A Master Vacuum already exists!", 0, (Sprite)null);
return false;
}
}
return true;
}
}
[HarmonyPatch(typeof(ZNetScene), "Awake")]
public static class ZNetSceneAwakePatch_Post
{
public static void Postfix(ZNetScene __instance, Dictionary<int, GameObject> ___m_namedPrefabs)
{
//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
//IL_00ec: Expected O, but got Unknown
//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
//IL_0102: Expected O, but got Unknown
ZRoutedRpc.instance.Register<ZDOID, ZPackage, ZDOID>("MasterVacuum_RequestIntake", (Action<long, ZDOID, ZPackage, ZDOID>)Instance.RPC_MasterVacuum_RequestIntake);
ZRoutedRpc.instance.Register<ZDOID>("MasterVacuum_ConfirmIntake", (Action<long, ZDOID>)Instance.RPC_MasterVacuum_ConfirmIntake);
if ((Object)(object)vacuumPrefab != (Object)null)
{
if (!__instance.m_prefabs.Contains(vacuumPrefab))
{
__instance.m_prefabs.Add(vacuumPrefab);
}
int stableHashCode = StringExtensionMethods.GetStableHashCode(((Object)vacuumPrefab).name);
if (!___m_namedPrefabs.ContainsKey(stableHashCode))
{
___m_namedPrefabs[stableHashCode] = vacuumPrefab;
}
Piece component = vacuumPrefab.GetComponent<Piece>();
GameObject prefab = __instance.GetPrefab("vfx_Place_chest");
GameObject prefab2 = __instance.GetPrefab("sfx_build_hammer_wood");
if ((Object)(object)component != (Object)null && (Object)(object)prefab != (Object)null)
{
component.m_placeEffect.m_effectPrefabs = (EffectData[])(object)new EffectData[2]
{
new EffectData
{
m_prefab = prefab,
m_enabled = true
},
new EffectData
{
m_prefab = prefab2,
m_enabled = true
}
};
}
}
}
}
[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
private static class RegisterAndSyncRPC
{
private static void Postfix(ZNet __instance, ZNetPeer peer)
{
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Expected O, but got Unknown
peer.m_rpc.Register<ZPackage>("MasterVacuum_RPC_SyncConfig", (Action<ZRpc, ZPackage>)RPC_MasterVacuum_SyncConfig);
if (ZNet.instance.IsServer())
{
logger.LogInfo((object)("Sending config to peer: " + peer.m_playerName));
ZPackage val = new ZPackage();
val.Write(PickUpMaterials.Value);
val.Write(PickUpConsumables.Value);
val.Write(PickUpTrophies.Value);
val.Write(PickUpEquipment.Value);
val.Write(PickUpMisc.Value);
peer.m_rpc.Invoke("MasterVacuum_RPC_SyncConfig", new object[1] { val });
}
}
private static void RPC_MasterVacuum_SyncConfig(ZRpc rpc, ZPackage pkg)
{
if (!ZNet.instance.IsServer())
{
logger.LogInfo((object)"Received config from server. Applying settings...");
PickUpMaterials.Value = pkg.ReadBool();
PickUpConsumables.Value = pkg.ReadBool();
PickUpTrophies.Value = pkg.ReadBool();
PickUpEquipment.Value = pkg.ReadBool();
PickUpMisc.Value = pkg.ReadBool();
}
}
}
[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
public static class ObjectDB_Patch
{
public static void Postfix(ObjectDB __instance)
{
GameObject itemPrefab = __instance.GetItemPrefab("Hammer");
if ((Object)(object)itemPrefab != (Object)null)
{
PieceTable buildPieces = itemPrefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces;
if ((Object)(object)vacuumPrefab != (Object)null && !buildPieces.m_pieces.Contains(vacuumPrefab))
{
buildPieces.m_pieces.Add(vacuumPrefab);
}
}
}
}
public static MasterVacuumPlugin Instance;
private const string ModGUID = "com.peep.mastervacuum";
private const string ModName = "Item Vacuum";
private const string ModVersion = "1.1.3";
public static ManualLogSource logger;
private readonly Harmony harmony = new Harmony("com.peep.mastervacuum");
private static GameObject vacuumPrefab;
private static MethodInfo _findObjectsMethod;
private static float m_distributeTimer = 0f;
private const string GlobalKeyName = "mastervacuum_zdoid";
public static readonly int HashWidth = StringExtensionMethods.GetStableHashCode("mastervac_width");
public static readonly int HashHeight = StringExtensionMethods.GetStableHashCode("mastervac_height");
public static readonly List<Container> TrackedContainers = new List<Container>();
private static Action<Player, bool> SetPlacementGhostValidDelegate;
public static ConfigEntry<bool> PickUpMaterials;
public static ConfigEntry<bool> PickUpConsumables;
public static ConfigEntry<bool> PickUpTrophies;
public static ConfigEntry<bool> PickUpEquipment;
public static ConfigEntry<bool> PickUpMisc;
public void Awake()
{
Instance = this;
logger = ((BaseUnityPlugin)this).Logger;
PickUpMaterials = ((BaseUnityPlugin)this).Config.Bind<bool>("Filters", "PickUpMaterials", true, "Pick up items like wood, stone, and ores.");
PickUpConsumables = ((BaseUnityPlugin)this).Config.Bind<bool>("Filters", "PickUpConsumables", true, "Pick up food and potions.");
PickUpTrophies = ((BaseUnityPlugin)this).Config.Bind<bool>("Filters", "PickUpTrophies", true, "Pick up monster trophies.");
PickUpEquipment = ((BaseUnityPlugin)this).Config.Bind<bool>("Filters", "PickUpEquipment", false, "Pick up weapons and armor.");
PickUpMisc = ((BaseUnityPlugin)this).Config.Bind<bool>("Filters", "PickUpMisc", false, "Pick up miscellaneous items.");
LoadAssets();
_findObjectsMethod = typeof(ZDOMan).GetMethod("FindObjects", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
{
typeof(Vector2i),
typeof(List<ZDO>)
}, null);
SetPlacementGhostValidDelegate = AccessTools.MethodDelegate<Action<Player, bool>>(AccessTools.Method(typeof(Player), "SetPlacementGhostValid", (Type[])null, (Type[])null), (object)null, true);
harmony.PatchAll();
logger.LogInfo((object)"Master Vacuum: Two-Way Handshake System Initialized.");
}
private void Update()
{
if (!((Object)(object)ZNet.instance == (Object)null))
{
m_distributeTimer += Time.deltaTime;
if (m_distributeTimer >= 5f)
{
m_distributeTimer = 0f;
ProcessVacuumCycle();
}
}
}
private void LoadAssets()
{
Assembly executingAssembly = Assembly.GetExecutingAssembly();
string text = executingAssembly.GetManifestResourceNames().FirstOrDefault((string str) => str.EndsWith("item_vacuum"));
if (text != null)
{
using (Stream stream = executingAssembly.GetManifestResourceStream(text))
{
AssetBundle obj = AssetBundle.LoadFromStream(stream);
vacuumPrefab = obj.LoadAsset<GameObject>("Item_Vacuum");
obj.Unload(false);
}
}
}
private void ProcessVacuumCycle()
{
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
//IL_00ce: Expected O, but got Unknown
//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
//IL_0128: Unknown result type (might be due to invalid IL or missing references)
//IL_012e: Unknown result type (might be due to invalid IL or missing references)
//IL_0397: Unknown result type (might be due to invalid IL or missing references)
//IL_039e: Expected O, but got Unknown
//IL_0278: Unknown result type (might be due to invalid IL or missing references)
//IL_027f: Expected O, but got Unknown
//IL_050c: Unknown result type (might be due to invalid IL or missing references)
//IL_0513: Expected O, but got Unknown
//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
//IL_02fb: Expected O, but got Unknown
string text = ZoneSystem.instance.m_globalKeysValues.Keys.FirstOrDefault((string k) => k.StartsWith("mastervacuum_zdoid"));
if (string.IsNullOrEmpty(text))
{
return;
}
string[] array = text.Split(new char[1] { '=' });
ZDOID masterID = ParseZDOID(array[1]);
ZDO zDO = ZDOMan.instance.GetZDO(masterID);
if (zDO == null)
{
ZoneSystem.instance.RemoveGlobalKey(array[0]);
return;
}
int @int = zDO.GetInt(HashWidth, 8);
int int2 = zDO.GetInt(HashHeight, 5);
Inventory inventoryFromZDO = GetInventoryFromZDO(zDO, @int, int2);
if (inventoryFromZDO.GetAllItems().Count == 0)
{
return;
}
Inventory val = new Inventory("tracker", (Sprite)null, @int, int2);
Container val2 = TrackedContainers.Find(delegate(Container c)
{
//IL_001a: 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)
if ((Object)(object)c != (Object)null)
{
ZNetView component3 = ((Component)c).GetComponent<ZNetView>();
if (component3 == null)
{
return false;
}
return component3.GetZDO().m_uid == masterID;
}
return false;
});
List<ZDO> list = FindAllZDOsInRange(zDO.GetPosition(), 30f, masterID);
bool flag = false;
foreach (ZDO containerZDO in list)
{
if (containerZDO.m_uid == masterID)
{
continue;
}
Container val3 = TrackedContainers.Find(delegate(Container c)
{
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//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_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)c != (Object)null)
{
ZNetView component2 = ((Component)c).GetComponent<ZNetView>();
ZDOID? val8 = ((component2 != null) ? new ZDOID?(component2.GetZDO().m_uid) : null);
ZDOID uid = containerZDO.m_uid;
if (!val8.HasValue)
{
return false;
}
return val8.GetValueOrDefault() == uid;
}
return false;
});
if ((Object)(object)val3 != (Object)null)
{
ZNetView component = ((Component)val3).GetComponent<ZNetView>();
Inventory inventory = val3.GetInventory();
if (component.IsOwner())
{
bool flag2 = false;
foreach (ItemData item in inventoryFromZDO.GetAllItems().ToList())
{
if (inventory.HaveItem(item.m_shared.m_name, true) && inventory.CanAddItem(item, -1))
{
inventory.AddItem(item);
inventoryFromZDO.RemoveItem(item);
if ((Object)(object)val2 != (Object)null && ((Component)val2).GetComponent<ZNetView>().IsOwner())
{
val2.GetInventory().RemoveItem(item.m_shared.m_name, item.m_stack, -1, true);
}
else if ((Object)(object)val2 != (Object)null)
{
val.AddItem(item);
}
flag = true;
flag2 = true;
}
}
if (flag2)
{
component.InvokeRPC(ZNetView.Everybody, "OnInventoryChanged", Array.Empty<object>());
}
}
else
{
Inventory val4 = new Inventory("temp", (Sprite)null, @int, int2);
foreach (ItemData item2 in inventoryFromZDO.GetAllItems().ToList())
{
if (inventory.HaveItem(item2.m_shared.m_name, true) && inventory.CanAddItem(item2, -1))
{
val4.AddItem(item2);
}
}
if (val4.GetAllItems().Count > 0)
{
ZPackage val5 = new ZPackage();
val4.Save(val5);
component.InvokeRPC(component.GetZDO().GetOwner(), "MasterVacuum_RequestAdd", new object[3]
{
((ZDOID)(ref masterID)).UserID,
((ZDOID)(ref masterID)).ID,
val5
});
}
}
}
else
{
int int3 = containerZDO.GetInt(HashWidth, 5);
int int4 = containerZDO.GetInt(HashHeight, 2);
Inventory inventoryFromZDO2 = GetInventoryFromZDO(containerZDO, int3, int4);
Inventory val6 = new Inventory("success", (Sprite)null, @int, int2);
bool flag3 = false;
foreach (ItemData item3 in inventoryFromZDO.GetAllItems().ToList())
{
if (inventoryFromZDO2.HaveItem(item3.m_shared.m_name, true) && inventoryFromZDO2.CanAddItem(item3, -1))
{
inventoryFromZDO2.AddItem(item3);
val6.AddItem(item3);
flag3 = true;
}
}
if (flag3)
{
SaveInventoryToZDO(inventoryFromZDO2, containerZDO);
foreach (ItemData allItem in val6.GetAllItems())
{
inventoryFromZDO.RemoveItem(allItem);
if ((Object)(object)val2 != (Object)null && ((Component)val2).GetComponent<ZNetView>().IsOwner())
{
val2.GetInventory().RemoveItem(allItem.m_shared.m_name, allItem.m_stack, -1, true);
}
else if ((Object)(object)val2 != (Object)null)
{
val.AddItem(allItem);
}
}
flag = true;
}
}
if (inventoryFromZDO.GetAllItems().Count == 0)
{
break;
}
}
if (flag)
{
if ((Object)(object)val2 != (Object)null && !((Component)val2).GetComponent<ZNetView>().IsOwner() && val.GetAllItems().Count > 0)
{
ZPackage val7 = new ZPackage();
val.Save(val7);
((Component)val2).GetComponent<ZNetView>().InvokeRPC(((Component)val2).GetComponent<ZNetView>().GetZDO().GetOwner(), "MasterVacuum_RequestRemove", new object[1] { val7 });
}
else if (zDO.IsOwner())
{
SaveInventoryToZDO(inventoryFromZDO, zDO);
}
}
}
public void RPC_MasterVacuum_ConfirmRemoval(long sender, long vacUserId, uint vacId, ZPackage pkg)
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: 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_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Expected O, but got Unknown
ZDOID vacuumID = new ZDOID(vacUserId, vacId);
ZDO zDO = ZDOMan.instance.GetZDO(vacuumID);
if (zDO == null || !zDO.IsOwner())
{
return;
}
int @int = zDO.GetInt(HashWidth, 8);
int int2 = zDO.GetInt(HashHeight, 5);
Inventory val = new Inventory("temp", (Sprite)null, @int, int2);
val.Load(pkg);
Container val2 = TrackedContainers.Find(delegate(Container c)
{
//IL_001a: 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)
if ((Object)(object)c != (Object)null)
{
ZNetView component = ((Component)c).GetComponent<ZNetView>();
if (component == null)
{
return false;
}
return component.GetZDO().m_uid == vacuumID;
}
return false;
});
if (zDO.IsOwner())
{
Inventory inventoryFromZDO = GetInventoryFromZDO(zDO, @int, int2);
bool flag = false;
foreach (ItemData allItem in val.GetAllItems())
{
if (inventoryFromZDO.HaveItem(allItem.m_shared.m_name, true))
{
inventoryFromZDO.RemoveItem(allItem.m_shared.m_name, allItem.m_stack, -1, true);
flag = true;
}
if ((Object)(object)val2 != (Object)null && ((Component)val2).GetComponent<ZNetView>().IsOwner())
{
val2.GetInventory().RemoveItem(allItem.m_shared.m_name, allItem.m_stack, -1, true);
}
}
if (flag)
{
SaveInventoryToZDO(inventoryFromZDO, zDO);
}
}
else if ((Object)(object)val2 != (Object)null)
{
((Component)val2).GetComponent<ZNetView>().InvokeRPC(zDO.GetOwner(), "MasterVacuum_RequestRemove", new object[1] { pkg });
}
}
public Inventory GetInventoryFromZDO(ZDO zdo, int width, int height)
{
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Expected O, but got Unknown
//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
//IL_00fa: Expected O, but got Unknown
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0114: Unknown result type (might be due to invalid IL or missing references)
//IL_011b: Expected O, but got Unknown
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Expected O, but got Unknown
foreach (Container trackedContainer in TrackedContainers)
{
if (!((Object)(object)trackedContainer != (Object)null))
{
continue;
}
ZNetView val = (ZNetView)typeof(Container).GetField("m_nview", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(trackedContainer);
if (!((Object)(object)val != (Object)null) || !(val.GetZDO().m_uid == zdo.m_uid))
{
continue;
}
Inventory inventory = trackedContainer.GetInventory();
Inventory val2 = new Inventory(inventory.GetName(), inventory.GetBkg(), width, height);
foreach (ItemData allItem in inventory.GetAllItems())
{
val2.AddItem(allItem.Clone());
}
return val2;
}
Inventory val3 = new Inventory("OfflineInventory", (Sprite)null, width, height);
string @string = zdo.GetString(ZDOVars.s_items, "");
if (!string.IsNullOrEmpty(@string))
{
ZPackage val4 = new ZPackage(@string);
val3.Load(val4);
}
return val3;
}
public void SaveInventoryToZDO(Inventory inv, ZDO zdo)
{
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Expected O, but got Unknown
//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
if (zdo == null || !zdo.IsValid())
{
return;
}
if (zdo.GetOwner() == 0L)
{
zdo.SetOwner(ZDOMan.GetSessionID());
}
if (!zdo.IsOwner())
{
return;
}
zdo.Set(HashWidth, inv.GetWidth(), false);
zdo.Set(HashHeight, inv.GetHeight(), false);
ZPackage val = new ZPackage();
inv.Save(val);
zdo.Set(ZDOVars.s_items, val.GetBase64());
uint dataRevision = zdo.DataRevision;
zdo.DataRevision = dataRevision + 1;
foreach (Container trackedContainer in TrackedContainers)
{
if (!((Object)(object)trackedContainer == (Object)null))
{
ZNetView value = Traverse.Create((object)trackedContainer).Field("m_nview").GetValue<ZNetView>();
if ((Object)(object)value != (Object)null && value.IsValid() && value.GetZDO().m_uid == zdo.m_uid)
{
value.InvokeRPC(ZNetView.Everybody, "OnInventoryChanged", Array.Empty<object>());
break;
}
}
}
}
private List<ZDO> FindAllZDOsInRange(Vector3 center, float radius, ZDOID ignore)
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: 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)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
List<ZDO> list = new List<ZDO>();
float num = radius * radius;
Vector2i zone = ZoneSystem.GetZone(center);
Vector2i val = default(Vector2i);
for (int i = -1; i <= 1; i++)
{
for (int j = -1; j <= 1; j++)
{
((Vector2i)(ref val))..ctor(zone.x + i, zone.y + j);
List<ZDO> list2 = new List<ZDO>();
_findObjectsMethod?.Invoke(ZDOMan.instance, new object[2] { val, list2 });
if (list2 == null)
{
continue;
}
foreach (ZDO item in list2)
{
if (item != null && !(item.m_uid == ignore) && Vector3.SqrMagnitude(item.GetPosition() - center) <= num)
{
list.Add(item);
}
}
}
}
return list;
}
public static ZDOID ParseZDOID(string id)
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
string[] array = id.Split(new char[1] { ':' });
if (array.Length == 2)
{
return new ZDOID(long.Parse(array[0]), uint.Parse(array[1]));
}
return ZDOID.None;
}
private static bool IsItemTypeAllowed(ItemType type)
{
//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_0048: Expected I4, but got Unknown
switch (type - 1)
{
case 0:
return PickUpMaterials.Value;
case 1:
return PickUpConsumables.Value;
case 12:
return PickUpTrophies.Value;
case 2:
case 3:
case 4:
case 5:
case 6:
case 10:
case 13:
return PickUpEquipment.Value;
case 15:
return PickUpMisc.Value;
default:
return true;
}
}
public void RPC_MasterVacuum_RequestIntake(long sender, ZDOID vacuumID, ZPackage itemPkg, ZDOID originalItemID)
{
//IL_0012: 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_0066: 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)
if (!ZNet.instance.IsServer())
{
return;
}
ZDO zDO = ZDOMan.instance.GetZDO(vacuumID);
if (zDO != null)
{
if (zDO.GetOwner() != ZDOMan.GetSessionID())
{
zDO.SetOwner(ZDOMan.GetSessionID());
}
int @int = zDO.GetInt(HashWidth, 8);
int int2 = zDO.GetInt(HashHeight, 5);
Inventory inventoryFromZDO = GetInventoryFromZDO(zDO, @int, int2);
Inventory val = new Inventory("temp", (Sprite)null, 1, 1);
val.Load(itemPkg);
ItemData itemAt = val.GetItemAt(0, 0);
if (itemAt != null && inventoryFromZDO.CanAddItem(itemAt, -1))
{
inventoryFromZDO.AddItem(itemAt);
SaveInventoryToZDO(inventoryFromZDO, zDO);
ZRoutedRpc.instance.InvokeRoutedRPC(sender, "MasterVacuum_ConfirmIntake", new object[1] { originalItemID });
}
}
}
public void RPC_MasterVacuum_ConfirmIntake(long sender, ZDOID itemID)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
GameObject val = ZNetScene.instance.FindInstance(itemID);
if ((Object)(object)val != (Object)null)
{
ZNetView component = val.GetComponent<ZNetView>();
if ((Object)(object)component != (Object)null && component.IsValid() && component.IsOwner())
{
component.Destroy();
}
}
}
}
