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.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LethalNetworkAPI;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Steamworks.Data;
using Unity.Netcode;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("ItemDeclutter")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Declutter your ship")]
[assembly: AssemblyFileVersion("0.0.1.0")]
[assembly: AssemblyInformationalVersion("0.0.1+7b05afce5e7f48f3c102e1f73b596cd56557d40f")]
[assembly: AssemblyProduct("ItemDeclutter")]
[assembly: AssemblyTitle("ItemDeclutter")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.1.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.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace ItemDeclutter
{
public class ConfigManager
{
public static ConfigManager Instance { get; private set; }
public static ConfigEntry<bool> DivideCheapExpensive { get; private set; }
public static ConfigEntry<int> ExpensiveValue { get; private set; }
public static ConfigEntry<bool> DivideOneTwoHanded { get; private set; }
public static ConfigEntry<bool> ShouldItemsAssumeZones { get; private set; }
public static void Init(ConfigFile config)
{
Instance = new ConfigManager(config);
}
private ConfigManager(ConfigFile config)
{
DivideCheapExpensive = config.Bind<bool>("Item Zones", "DivideCheapExpensive", true, "Divide cheap and expensive items into different zones.");
ExpensiveValue = config.Bind<int>("Item Zones", "ExpensiveValue", 65, "At what point value is considered expensive?");
DivideOneTwoHanded = config.Bind<bool>("Item Zones", "DivideOneTwoHanded", true, "Divide normal and two handed items into different zones.");
ShouldItemsAssumeZones = config.Bind<bool>("Item Zones", "ShouldItemsAssumeZones", true, "Should items assume zones if they are not defined in the config?");
}
}
public class ZoneManagerConfig
{
public static ConfigEntry<bool> LogCreatedZones { get; private set; }
public static ConfigEntry<float> ZoningStartX { get; private set; }
public static ConfigEntry<float> ZoningStartY { get; private set; }
public static ConfigEntry<float> ZoningStartZ { get; private set; }
public static ConfigEntry<float> ZoneDistanceX { get; private set; }
public static ConfigEntry<float> ZoneDistanceY { get; private set; }
public static ConfigEntry<float> ZoneDistanceZ { get; private set; }
public static ConfigEntry<int> HowManyZonesX { get; private set; }
public static ConfigEntry<int> HowManyZonesY { get; private set; }
public static ConfigEntry<int> HowManyZonesZ { get; private set; }
public static ZoneManagerConfig Instance { get; private set; }
public static ConfigEntry<bool> Debug { get; private set; }
public static void Init(ConfigFile config)
{
Instance = new ZoneManagerConfig(config);
}
private ZoneManagerConfig(ConfigFile config)
{
LogCreatedZones = config.Bind<bool>("Log created zones", "Log", true, "Log created zones to console.");
ZoningStartX = config.Bind<float>("Start Position", "ZoningStartX", -6f, "Start position on X axis (entrance -> console)");
ZoningStartY = config.Bind<float>("Start Position", "ZoningStartY", 0.25f, "Start position on Y axis (floor -> ceiling)");
ZoningStartZ = config.Bind<float>("Start Position", "ZoningStartZ", -5f, "Start position on Z axis (left -> right)");
ZoneDistanceX = config.Bind<float>("Distance between zones", "ZoneDistanceX", 0.65f, "Distance between zones on X axis (entrance -> console)");
ZoneDistanceY = config.Bind<float>("Distance between zones", "ZoneDistanceY", 1.25f, "Distance between zones on Y axis (floor -> ceiling)");
ZoneDistanceZ = config.Bind<float>("Distance between zones", "ZoneDistanceZ", 1f, "Distance between zones on Z axis (left -> right)");
HowManyZonesX = config.Bind<int>("How many zones to create", "HowManyZonesX", 20, "How many zones on X axis (entrance -> console)");
HowManyZonesY = config.Bind<int>("How many zones to create", "HowManyZonesY", 5, "How many zones on Y axis (floor -> ceiling)");
HowManyZonesZ = config.Bind<int>("How many zones to create", "HowManyZonesZ", 4, "How many zones on Z axis (left -> right)");
}
}
[JsonObject(/*Could not decode attribute arguments.*/)]
public class PositionData
{
[JsonProperty]
public string ItemName { get; set; }
[JsonProperty]
public Vector3 Position { get; set; }
}
internal class ConfigSync
{
public static LethalServerMessage<string> sendItemConfig = new LethalServerMessage<string>("configData", (Action<string, ulong>)null);
public static LethalClientMessage<string> receiveItemConfig = new LethalClientMessage<string>("configData", (Action<string>)null, (Action<string, ulong>)null);
public static LethalServerMessage<string> sendItemPosition = new LethalServerMessage<string>("itemPositionData", (Action<string, ulong>)null);
public static LethalClientMessage<string> receiveItemPosition = new LethalClientMessage<string>("itemPositionData", (Action<string>)null, (Action<string, ulong>)null);
public static LethalServerEvent sendItemPositionEvent = new LethalServerEvent("itemPositionEvent", (Action<ulong>)null);
public static LethalClientEvent receiveItemPositionEvent = new LethalClientEvent("itemPositionEvent", (Action)null, (Action<ulong>)null);
public static LethalNetworkVariable<string> synchronizedConfig = new LethalNetworkVariable<string>("synchronizedConfig");
public static void Start()
{
sendItemPositionEvent.OnReceived += ItemPositionRequest;
synchronizedConfig.OnValueChanged += MessageReceivedFromServer;
receiveItemPosition.OnReceived += ItemPositionReceived;
}
private static void MessageReceivedFromServer(string message)
{
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
if (((NetworkBehaviour)StartOfRound.Instance).IsHost)
{
return;
}
Plugin.logger.LogInfo((object)("Config received from server: " + message));
List<PositionData> list = JsonConvert.DeserializeObject<List<PositionData>>(message);
foreach (PositionData item in list)
{
Plugin.logger.LogInfo((object)$"Deserialized: {item.ItemName} - {item.Position}");
Positions.PositionsDictionary[item.ItemName] = item.Position;
}
}
private static void ItemPositionReceived(string message)
{
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
if (!((NetworkBehaviour)StartOfRound.Instance).IsHost)
{
Plugin.logger.LogInfo((object)("Item settings received from server: " + message));
PositionData positionData = JsonConvert.DeserializeObject<PositionData>(message);
Positions.PositionsDictionary[positionData.ItemName] = positionData.Position;
}
}
private static void ItemPositionRequest(ulong clientId)
{
Plugin.logger.LogInfo((object)"ItemPositionRequest called");
if (((NetworkBehaviour)StartOfRound.Instance).IsHost)
{
SendItemsPositionData(clientId);
}
}
public static void SendItemsPositionData(ulong clientId)
{
//IL_000e: 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)
//IL_0020: Expected O, but got Unknown
List<PositionData> itemsPositionData = GetItemsPositionData();
sendItemConfig.SendClient(JsonConvert.SerializeObject((object)itemsPositionData, (Formatting)0, new JsonSerializerSettings
{
ReferenceLoopHandling = (ReferenceLoopHandling)1
}), clientId);
Plugin.logger.LogInfo((object)$"Sending data: {itemsPositionData}");
}
public static void SetNetworkedConfig()
{
//IL_000e: 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)
//IL_0020: Expected O, but got Unknown
//IL_0054: 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)
List<PositionData> itemsPositionData = GetItemsPositionData();
synchronizedConfig.Value = JsonConvert.SerializeObject((object)itemsPositionData, (Formatting)0, new JsonSerializerSettings
{
ReferenceLoopHandling = (ReferenceLoopHandling)1
});
Plugin.logger.LogInfo((object)$"Setting networked config: {itemsPositionData}");
Lobby? currentLobby = GameNetworkManager.Instance.currentLobby;
if (currentLobby.HasValue)
{
Lobby valueOrDefault = currentLobby.GetValueOrDefault();
((Lobby)(ref valueOrDefault)).SetData("ItemDeclutterConfig", synchronizedConfig.Value);
}
}
public static List<PositionData> GetItemsPositionData()
{
//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_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_00a2: 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)
List<PositionData> list = new List<PositionData>();
foreach (string key in Positions.PositionsDictionary.Keys)
{
Vector3 val = Positions.PositionsDictionary[key];
if (Positions.DroppedItemsYCoordinateDictionary.ContainsKey(key))
{
val.y = Positions.DroppedItemsYCoordinateDictionary[key];
Plugin.logger.LogInfo((object)$"Updating {key} Y coordinate from dictionary: {val.y}");
}
PositionData positionData = new PositionData
{
ItemName = key,
Position = val
};
Plugin.logger.LogInfo((object)$"Serialized: {positionData.ItemName} - {positionData.Position}");
list.Add(positionData);
}
return list;
}
public static void DeserializeConfig(string serialized)
{
//IL_0046: 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)
if (serialized == "" || serialized == null)
{
return;
}
List<PositionData> list = JsonConvert.DeserializeObject<List<PositionData>>(serialized);
foreach (PositionData item in list)
{
Plugin.logger.LogInfo((object)$"Deserialized: {item.ItemName} - {item.Position}");
Positions.PositionsDictionary[item.ItemName] = item.Position;
}
}
public static string GetSerializedConfig()
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Expected O, but got Unknown
return JsonConvert.SerializeObject((object)GetItemsPositionData(), (Formatting)0, new JsonSerializerSettings
{
ReferenceLoopHandling = (ReferenceLoopHandling)1
});
}
public static void UpdateItemPositionData(GrabbableObject item)
{
//IL_004b: 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_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Expected O, but got Unknown
if (((NetworkBehaviour)StartOfRound.Instance).IsHost)
{
Plugin.logger.LogInfo((object)"Updating item position data");
PositionData positionData = new PositionData
{
ItemName = item.itemProperties.itemName,
Position = Positions.PositionsDictionary[item.itemProperties.itemName]
};
sendItemPosition.SendAllClients(JsonConvert.SerializeObject((object)positionData, (Formatting)0, new JsonSerializerSettings
{
ReferenceLoopHandling = (ReferenceLoopHandling)1
}), true);
Plugin.logger.LogInfo((object)$"Sending {item.itemProperties.itemName} data: {positionData}");
}
}
}
[HarmonyPatch(typeof(GrabbableObject))]
internal class FallToGroundPatch
{
[HarmonyPatch("FallToGround")]
[HarmonyPrefix]
internal static bool FallToGroundPatchLogic(GrabbableObject __instance, ref bool randomizePosition)
{
//IL_0195: Unknown result type (might be due to invalid IL or missing references)
//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
//IL_021a: Unknown result type (might be due to invalid IL or missing references)
//IL_021f: Unknown result type (might be due to invalid IL or missing references)
Plugin.logger.LogDebug((object)("FallToGroundPatchLogic called for " + __instance.itemProperties.itemName + "."));
if ((Object)(object)__instance == (Object)null)
{
return true;
}
if ((Object)(object)((Component)__instance).transform.parent == (Object)null)
{
return true;
}
Plugin.logger.LogDebug((object)("Transform parent name: " + ((Object)((Component)__instance).transform.parent).name));
if (((Object)((Component)__instance).transform.parent).name == "HangarShip")
{
string name = ItemZone.GetName(__instance);
Plugin.logger.LogDebug((object)("Resolved zone for " + __instance.itemProperties.itemName + " to " + name));
if (name == null)
{
return true;
}
if (name == true.ToString())
{
Plugin.logger.LogDebug((object)(__instance.itemProperties.itemName + " is in the dictionary - zone " + name));
}
else
{
Plugin.logger.LogDebug((object)(__instance.itemProperties.itemName + " is not in the dictionary - checking if " + name + " is a valid zone name."));
if (!Positions.Zones.ContainsKey(name))
{
Plugin.logger.LogDebug((object)(name + " is not a valid zone name."));
return true;
}
Plugin.logger.LogDebug((object)(name + " is a valid zone name - adding " + __instance.itemProperties.itemName + " to the dictionary."));
Positions.PositionsDictionary[__instance.itemProperties.itemName] = Positions.Zones[name];
}
if (ZoneManagerConfig.ZoningStartY.Value != ((Component)__instance).transform.localPosition.y)
{
Plugin.logger.LogDebug((object)(__instance.itemProperties.itemName + "'s position is not on the floor."));
__instance.targetFloorPosition = Positions.PositionsDictionary[__instance.itemProperties.itemName];
return false;
}
return true;
}
Plugin.logger.LogMessage((object)(__instance.itemProperties.itemName + " is not on the ship. - calling original method."));
return true;
}
}
public static class ItemZone
{
public static string GetName(GrabbableObject droppedObject)
{
if (Positions.PositionsDictionary.ContainsKey(droppedObject.itemProperties.itemName))
{
return true.ToString();
}
bool isScrap = droppedObject.itemProperties.isScrap;
bool twoHanded = droppedObject.itemProperties.twoHanded;
int scrapValue = droppedObject.scrapValue;
return null;
}
public static Vector3 GetCoordinates(GrabbableObject droppedObject)
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0078: 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)
//IL_0075: 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_0063: Unknown result type (might be due to invalid IL or missing references)
string name = GetName(droppedObject);
if (name == null)
{
return Vector3.zero;
}
if (name == true.ToString())
{
return Positions.PositionsDictionary[droppedObject.itemProperties.itemName];
}
if (Positions.Zones.ContainsKey(name))
{
return Positions.Zones[name];
}
return Positions.Zones["Default"];
}
}
internal class ItemStackTooltip
{
public static string UpdateAllTooltips(string itemName)
{
GameObject val = GameObject.Find("/Environment/HangarShip");
List<GrabbableObject> ItemsOnShip = (from obj in val.GetComponentsInChildren<GrabbableObject>()
where obj.itemProperties.itemName == itemName
select obj).ToList();
List<GrabbableObject> list = ItemsOnShip.ToList();
if (list.Count() == 0)
{
return null;
}
if (!Positions.PositionsDictionary.ContainsKey(itemName))
{
return null;
}
CollectionExtensions.Do<GrabbableObject>((IEnumerable<GrabbableObject>)list, (Action<GrabbableObject>)delegate(GrabbableObject item)
{
if ((Object)(object)item.playerHeldBy != (Object)null)
{
Plugin.logger.LogDebug((object)("Found a player holding " + item.itemProperties.itemName));
ItemsOnShip.Remove(item);
}
});
int num = ItemsOnShip.Count();
Plugin.logger.LogInfo((object)$"Found {num} {itemName} on ship");
string text = $"{itemName} (x{num}) \n Grab : [E]";
foreach (GrabbableObject item in ItemsOnShip)
{
item.customGrabTooltip = text;
}
return text;
}
}
[HarmonyPatch(typeof(StartOfRound))]
internal class JoinServerPatch
{
internal static Dictionary<string, LethalNetworkVariable<Vector3>> ItemZoneSynchronizedConfig = new Dictionary<string, LethalNetworkVariable<Vector3>>();
[HarmonyPatch("Start")]
[HarmonyPostfix]
internal static void PatchLogic()
{
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
bool isHost = ((NetworkBehaviour)StartOfRound.Instance).IsHost;
Plugin.logger.LogInfo((object)$"JoinServerPatch called - isHost: {isHost}");
if (isHost)
{
return;
}
Plugin.logger.LogInfo((object)"creating weird shit on client");
Positions.PositionsDictionary.Clear();
if (!GameNetworkManager.Instance.disableSteam && GameNetworkManager.Instance.currentLobby.HasValue)
{
Lobby? currentLobby = GameNetworkManager.Instance.currentLobby;
object obj;
if (!currentLobby.HasValue)
{
obj = null;
}
else
{
Lobby valueOrDefault = currentLobby.GetValueOrDefault();
obj = ((Lobby)(ref valueOrDefault)).GetData("ItemDeclutterConfig");
}
string serialized = (string)obj;
ConfigSync.DeserializeConfig(serialized);
}
ConfigSync.receiveItemPositionEvent.InvokeServer();
}
}
[HarmonyPatch(typeof(StartOfRound))]
internal class LoadIntoShipPatch
{
internal static Dictionary<string, ConfigEntry<string>> ItemZoneConfig = new Dictionary<string, ConfigEntry<string>>();
[HarmonyPatch("LoadShipGrabbableItems")]
[HarmonyPrefix]
internal static void PatchLogic()
{
Positions.PositionsDictionary.Clear();
Positions.ZoneAllocated.Clear();
Positions.Zones.Clear();
CreateZones();
PopulateItemScrapConfig();
TranslateDictionaries();
ConfigSync.SetNetworkedConfig();
}
internal static void PopulateItemScrapConfig()
{
List<Item> itemsList = StartOfRound.Instance.allItemsList.itemsList;
foreach (Item item in itemsList)
{
if (!item.isScrap)
{
string text = "";
if (Positions.DefaultZones.ContainsKey(item.itemName))
{
Plugin.logger.LogMessage((object)(item.itemName + " has a default zone : " + Positions.DefaultZones[item.itemName]));
text = Positions.DefaultZones[item.itemName];
}
ItemZoneConfig[item.itemName] = Plugin.ItemZoneConfig.Bind<string>(item.itemName, item.itemName, text, "Set zone for " + item.itemName + ".");
Plugin.logger.LogMessage((object)("Added config entry for " + item.itemName + "."));
Plugin.logger.LogMessage((object)("ItemZoneConfig[item.itemName]: " + ItemZoneConfig[item.itemName].Value));
}
}
foreach (Item item2 in itemsList)
{
if (item2.isScrap)
{
string text2 = "";
if (Positions.DefaultZones.ContainsKey(item2.itemName))
{
Plugin.logger.LogMessage((object)(item2.itemName + " has a default zone : " + Positions.DefaultZones[item2.itemName]));
text2 = Positions.DefaultZones[item2.itemName];
}
ItemZoneConfig[item2.itemName] = Plugin.ScrapZoneConfig.Bind<string>(item2.itemName, item2.itemName, text2, "Set zone for " + item2.itemName + ".");
Plugin.logger.LogMessage((object)("Added config entry for " + item2.itemName + "."));
Plugin.logger.LogMessage((object)("ItemZoneConfig[item.itemName]: " + ItemZoneConfig[item2.itemName].Value));
}
}
}
internal static void CreateZones()
{
//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
Vector3 val = default(Vector3);
for (int i = 0; i < ZoneManagerConfig.HowManyZonesY.Value; i++)
{
for (int j = 0; j < ZoneManagerConfig.HowManyZonesX.Value; j++)
{
for (int k = 0; k < ZoneManagerConfig.HowManyZonesZ.Value; k++)
{
string text = ZoneNames.zoneYNames[i] + k.ToString("0") + j.ToString("00");
((Vector3)(ref val))..ctor(ZoneManagerConfig.ZoningStartX.Value + ZoneManagerConfig.ZoneDistanceX.Value * (float)j, ZoneManagerConfig.ZoningStartY.Value + ZoneManagerConfig.ZoneDistanceY.Value * (float)i, ZoneManagerConfig.ZoningStartZ.Value + ZoneManagerConfig.ZoneDistanceZ.Value * (float)k * -1f);
if (ZoneManagerConfig.LogCreatedZones.Value)
{
Plugin.logger.LogInfo((object)$"Created zone {text} at {val.x}, {val.y}, {val.z}");
}
Positions.Zones.Add(text, val);
}
}
}
}
internal static void TranslateDictionaries()
{
//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
//IL_0100: Unknown result type (might be due to invalid IL or missing references)
//IL_0130: Unknown result type (might be due to invalid IL or missing references)
//IL_013e: Unknown result type (might be due to invalid IL or missing references)
//IL_014c: Unknown result type (might be due to invalid IL or missing references)
foreach (KeyValuePair<string, ConfigEntry<string>> item in ItemZoneConfig)
{
string value = item.Value.Value;
if (value == null || value == "")
{
continue;
}
if (!Positions.Zones.ContainsKey(value))
{
Plugin.logger.LogMessage((object)("Zone " + value + " does not exist - skipping."));
continue;
}
if (Positions.PositionsDictionary.ContainsKey(item.Key))
{
Plugin.logger.LogMessage((object)(item.Key + " is already in the dictionary - changing default position to configured."));
Positions.PositionsDictionary.Remove(item.Key);
Positions.ZoneAllocated.Remove(value);
}
Vector3 val = Positions.Zones[value];
Plugin.logger.LogMessage((object)$"itemZone: {value}, itemPosition: {val}");
Positions.PositionsDictionary.Add(item.Key, val);
Positions.ZoneAllocated.Add(value, value: true);
Plugin.logger.LogMessage((object)$"Added {item.Key} to PositionsDictionary with position {val.x}, {val.y}, {val.z}.");
}
}
internal static void AssumeZones()
{
List<Item> itemsList = StartOfRound.Instance.allItemsList.itemsList;
foreach (Item item in itemsList)
{
if (!item.isScrap)
{
if (Positions.PositionsDictionary.ContainsKey(item.itemName))
{
Plugin.logger.LogMessage((object)(item.itemName + " is already in the dictionary - skipping."));
continue;
}
Plugin.logger.LogMessage((object)(item.itemName + " is not in the dictionary - finding a free zone."));
FindFurthestFreeZone(item);
}
}
}
internal static void FindFurthestFreeZone(Item item)
{
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: 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)
int num = ZoneManagerConfig.HowManyZonesX.Value - 1;
int num2 = ZoneManagerConfig.HowManyZonesZ.Value - 1;
for (int num3 = num; num3 >= 0; num3--)
{
for (int num4 = num2; num4 >= 0; num4--)
{
string text = "A" + num4.ToString("0") + num3.ToString("00");
Vector3 value = Positions.Zones[text];
if (!Positions.ZoneAllocated.ContainsKey(text))
{
Positions.PositionsDictionary.Add(item.itemName, value);
Positions.ZoneAllocated.Add(text, value: true);
Plugin.logger.LogMessage((object)("Auto-allocated " + item.itemName + " into zone " + text + "."));
return;
}
}
}
}
}
[HarmonyPatch(typeof(PlayerControllerB))]
internal class PlayerDropItemPatch
{
[HarmonyPatch("SetObjectAsNoLongerHeld")]
[HarmonyPrefix]
internal static void ItemDroppedOnShipPatch(bool droppedInElevator, bool droppedInShipRoom, ref Vector3 targetFloorPosition, ref GrabbableObject dropObject, ref int floorYRot)
{
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//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)
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
//IL_00df: Unknown result type (might be due to invalid IL or missing references)
//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
//IL_0107: Unknown result type (might be due to invalid IL or missing references)
//IL_0109: Unknown result type (might be due to invalid IL or missing references)
//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
if (!droppedInShipRoom)
{
return;
}
string itemName = dropObject.itemProperties.itemName;
Plugin.logger.LogInfo((object)$"Dropped {itemName} in ship room at {targetFloorPosition.x}, {targetFloorPosition.y}, {targetFloorPosition.z}");
if (!Positions.PositionsDictionary.ContainsKey(itemName))
{
return;
}
Vector3 coordinates = ItemZone.GetCoordinates(dropObject);
Vector3 val = targetFloorPosition;
bool flag = false;
Vector3 val2 = coordinates;
Plugin.logger.LogInfo((object)$"Dropped {itemName} in ship room at {targetFloorPosition.x}, {targetFloorPosition.y}, {targetFloorPosition.z} - updating drop position to {val2.x}, {val2.y}, {val2.z}");
targetFloorPosition = val2;
if (ZoneManagerConfig.ZoningStartY.Value == targetFloorPosition.y)
{
Plugin.logger.LogDebug((object)(dropObject.itemProperties.itemName + "'s position is in the lowest zone - resolving Y coordinate"));
if (Positions.DroppedItemsYCoordinateDictionary.ContainsKey(itemName))
{
Plugin.logger.LogDebug((object)$"{dropObject.itemProperties.itemName} is in the Y coordinate dictionary - updating Y coordinate to {Positions.DroppedItemsYCoordinateDictionary[itemName]}");
targetFloorPosition.y = Positions.DroppedItemsYCoordinateDictionary[itemName];
}
else
{
targetFloorPosition.y = val.y;
dropObject.FallToGround(false);
Positions.DroppedItemsYCoordinateDictionary[itemName] = val.y;
Plugin.logger.LogDebug((object)$"{dropObject.itemProperties.itemName} is not in the Y coordinate dictionary - updating Y coordinate to {val.y} and adding to dictionary");
ConfigSync.UpdateItemPositionData(dropObject);
}
}
floorYRot = 0;
}
[HarmonyPatch(typeof(GrabbableObject))]
[HarmonyPatch("DiscardItemClientRpc")]
[HarmonyPostfix]
internal static void ItemDroppedOnShipPatchPostfix(GrabbableObject __instance)
{
if (__instance.isInShipRoom)
{
string itemName = __instance.itemProperties.itemName;
__instance.customGrabTooltip = ItemStackTooltip.UpdateAllTooltips(itemName);
}
else
{
__instance.customGrabTooltip = null;
}
}
}
[HarmonyPatch(typeof(PlayerControllerB))]
internal class PlayerPickupItem
{
[HarmonyPatch("GrabObjectClientRpc")]
[HarmonyPostfix]
internal static void GrabObjectPatch(bool grabValidated, ref NetworkObjectReference grabbedObject)
{
NetworkObject val = default(NetworkObject);
((NetworkObjectReference)(ref grabbedObject)).TryGet(ref val, (NetworkManager)null);
if (!((Object)(object)val == (Object)null))
{
GrabbableObject component = ((Component)val).GetComponent<GrabbableObject>();
if (!((Object)(object)component == (Object)null))
{
string itemName = component.itemProperties.itemName;
component.customGrabTooltip = ItemStackTooltip.UpdateAllTooltips(itemName);
}
}
}
}
[HarmonyPatch(typeof(StartOfRound))]
internal class SetShipReadyToLand
{
[HarmonyPatch("SetShipReadyToLand")]
[HarmonyPrefix]
internal static void PatchLogic()
{
Plugin.logger.LogInfo((object)"SetShipReadyToLand called");
GameObject val = GameObject.Find("/Environment/HangarShip");
GrabbableObject[] componentsInChildren = val.GetComponentsInChildren<GrabbableObject>();
foreach (KeyValuePair<string, Vector3> item in Positions.PositionsDictionary)
{
IEnumerable<GrabbableObject> source = componentsInChildren.Where((GrabbableObject obj) => obj.itemProperties.itemName == item.Key);
Plugin.logger.LogDebug((object)$"Found {source.Count()} items of type {item.Key}");
if (source.Count() != 0)
{
ItemStackTooltip.UpdateAllTooltips(item.Key);
}
}
}
}
[HarmonyPatch(typeof(StartOfRound))]
internal class ShipLoadItems
{
[HarmonyPatch("LoadShipGrabbableItems")]
[HarmonyPostfix]
internal static void LoadShipItemsPatch()
{
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
GameObject val = GameObject.Find("/Environment/HangarShip");
GrabbableObject[] componentsInChildren = val.GetComponentsInChildren<GrabbableObject>();
foreach (KeyValuePair<string, Vector3> item in Positions.PositionsDictionary)
{
IEnumerable<GrabbableObject> enumerable = componentsInChildren.Where((GrabbableObject obj) => obj.itemProperties.itemName == item.Key);
Plugin.logger.LogDebug((object)$"Found {enumerable.Count()} items of type {item.Key}");
if (enumerable.Count() == 0)
{
continue;
}
foreach (GrabbableObject item2 in enumerable)
{
Vector3 value = item.Value;
((Component)item2).transform.localPosition = value;
item2.isInShipRoom = true;
if (ZoneManagerConfig.ZoningStartY.Value == value.y)
{
item2.FallToGround(false);
Positions.DroppedItemsYCoordinateDictionary[item.Key] = item2.targetFloorPosition.y;
Plugin.logger.LogDebug((object)$"{item.Key}'s position is in the lowest zone (on the floor) - updating Y coordinate dictionary to {item2.targetFloorPosition.y}");
}
}
ItemStackTooltip.UpdateAllTooltips(item.Key);
}
}
}
[BepInPlugin("ItemDeclutter", "ItemDeclutter", "0.0.1")]
public class Plugin : BaseUnityPlugin
{
internal static ManualLogSource logger;
private readonly Harmony harmony = new Harmony("ItemDeclutter");
public static ConfigFile ItemZoneConfig = new ConfigFile(Path.Combine(Paths.ConfigPath, "Declutter/Items.cfg"), true);
public static ConfigFile ScrapZoneConfig = new ConfigFile(Path.Combine(Paths.ConfigPath, "Declutter/Scrap.cfg"), true);
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_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
ConfigManager.Init(new ConfigFile(Path.Combine(Paths.ConfigPath, "Declutter/BaseConfig.cfg"), true));
ZoneManagerConfig.Init(new ConfigFile(Path.Combine(Paths.ConfigPath, "Declutter/DefineZones.cfg"), true));
logger = ((BaseUnityPlugin)this).Logger;
harmony.PatchAll();
ConfigSync.Start();
((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin ItemDeclutter is loaded!");
}
}
public class Positions
{
public static Dictionary<string, Vector3> Zones = new Dictionary<string, Vector3>();
public static Dictionary<string, bool> ZoneAllocated = new Dictionary<string, bool>();
public static Dictionary<string, float> DroppedItemsYCoordinateDictionary = new Dictionary<string, float>();
public static Dictionary<string, Vector3> PositionsDictionary = new Dictionary<string, Vector3>();
public static Dictionary<string, string> DefaultZones = new Dictionary<string, string>
{
{ "Default", "A000" },
{ "Shovel", "A000" },
{ "Stun grenade", "A002" },
{ "Pro-flashlight", "A003" },
{ "Flashlight", "A103" },
{ "Walkie-talkie", "A004" },
{ "Lockpicker", "A005" },
{ "Key", "A105" },
{ "Shotgun", "A006" },
{ "Ammo", "A007" },
{ "Spray paint", "A008" },
{ "Zap gun", "A009" },
{ "Jetpack", "D301" },
{ "Extension ladder", "D001" }
};
public static Vector3 vectorConstrctor(double x, double y, double z)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
return new Vector3((float)x, (float)y, (float)z);
}
}
public class ZoneNames
{
public static string[] zoneYNames = new string[6] { "A", "B", "C", "D", "E", "F" };
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "ItemDeclutter";
public const string PLUGIN_NAME = "ItemDeclutter";
public const string PLUGIN_VERSION = "0.0.1";
}
}
