the initial commit to the repo.

stoopid.raw/ItemFactory.cs

@@ -0,0 +1,258 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using Comfort.Common;
+using EFT;
+using EFT.InventoryLogic;
+using UnityEngine;
+
+public class ItemFactory
+{
+	public class ContainerCollection
+	{
+		private static Type _containerCollectionType;
+
+		private static PropertyInfo _containersProperty;
+
+		private static MethodInfo _getContainerMethod;
+
+		private static MethodInfo _tryFindItemMethod;
+
+		public IEnumerable<IContainer> Containers
+		{
+			get
+			{
+				if (_containersProperty != null)
+				{
+					return (IEnumerable<IContainer>)_containersProperty.GetValue(this);
+				}
+				return null;
+			}
+		}
+
+		static ContainerCollection()
+		{
+			LoadContainerCollectionType();
+		}
+
+		private static void LoadContainerCollectionType()
+		{
+			Assembly assembly = Assembly.Load("Assembly-CSharp");
+			if (assembly == null)
+			{
+				Log("Log: Failed to load Assembly-CSharp.");
+				return;
+			}
+			Type[] types = assembly.GetTypes();
+			foreach (Type type in types)
+			{
+				if (type.Name == "\uecea")
+				{
+					_containerCollectionType = type;
+					break;
+				}
+			}
+			if (!(_containerCollectionType == null))
+			{
+				_containersProperty = _containerCollectionType.GetProperty("Containers", BindingFlags.Instance | BindingFlags.Public);
+				_getContainerMethod = _containerCollectionType.GetMethod("GetContainer", BindingFlags.Instance | BindingFlags.Public);
+				_tryFindItemMethod = _containerCollectionType.GetMethod("TryFindItem", BindingFlags.Instance | BindingFlags.Public);
+			}
+		}
+
+		public IContainer GetContainer(string containerId)
+		{
+			if (_getContainerMethod != null)
+			{
+				return (IContainer)_getContainerMethod.Invoke(this, new object[1] { containerId });
+			}
+			return null;
+		}
+
+		public bool TryFindItem(string itemId, out Item item)
+		{
+			item = null;
+			if (_tryFindItemMethod != null)
+			{
+				object[] array = new object[2] { itemId, null };
+				bool result = (bool)_tryFindItemMethod.Invoke(this, array);
+				item = (Item)array[1];
+				return result;
+			}
+			return false;
+		}
+
+		public static void Log(string message)
+		{
+			using StreamWriter streamWriter = new StreamWriter(Path.Combine(Application.persistentDataPath, "log.txt"), append: true);
+			streamWriter.WriteLine($"{DateTime.Now}: {message}");
+		}
+	}
+
+	public class GridHelper
+	{
+		public LocationInGrid FindFreeSpace(Item item, dynamic grid)
+		{
+			_E374 obj = item.CalculateCellSize();
+			int x = obj.X;
+			int y = obj.Y;
+			int num = grid.GridWidth;
+			int num2 = grid.GridHeight;
+			dynamic val = grid.ItemCollection;
+			dynamic occupiedSpaces = GetOccupiedSpaces(val);
+			LocationInGrid locationInGrid = TryFindLocation(x, y, num, num2, occupiedSpaces);
+			if (locationInGrid == null && x != y)
+			{
+				locationInGrid = TryFindLocation(y, x, num, num2, occupiedSpaces);
+			}
+			if (locationInGrid == null)
+			{
+				locationInGrid = HandleStretching(x, y, grid, num, num2);
+			}
+			return locationInGrid;
+		}
+
+		private Dictionary<(int, int), bool> GetOccupiedSpaces(dynamic itemCollection)
+		{
+			Dictionary<(int, int), bool> dictionary = new Dictionary<(int, int), bool>();
+			foreach (dynamic item in itemCollection.Values)
+			{
+				dynamic val = item.Position;
+				dynamic val2 = item.CalculateCellSize();
+				int num = val2.X;
+				int num2 = val2.Y;
+				for (int i = val.X; i < val.X + num; i++)
+				{
+					for (int j = val.Y; j < val.Y + num2; j++)
+					{
+						dictionary[(i, j)] = true;
+					}
+				}
+			}
+			return dictionary;
+		}
+
+		private LocationInGrid TryFindLocation(int itemWidth, int itemHeight, int gridWidth, int gridHeight, Dictionary<(int, int), bool> occupiedSpaces)
+		{
+			for (int i = 0; i <= gridWidth - itemWidth; i++)
+			{
+				for (int j = 0; j <= gridHeight - itemHeight; j++)
+				{
+					if (IsSpaceAvailable(i, j, itemWidth, itemHeight, occupiedSpaces))
+					{
+						return new LocationInGrid(i, j, ItemRotation.Horizontal);
+					}
+				}
+			}
+			return null;
+		}
+
+		private bool IsSpaceAvailable(int startX, int startY, int itemWidth, int itemHeight, Dictionary<(int, int), bool> occupiedSpaces)
+		{
+			for (int i = startX; i < startX + itemWidth; i++)
+			{
+				for (int j = startY; j < startY + itemHeight; j++)
+				{
+					if (occupiedSpaces.ContainsKey((i, j)))
+					{
+						return false;
+					}
+				}
+			}
+			return true;
+		}
+
+		private LocationInGrid HandleStretching(int itemWidth, int itemHeight, dynamic grid, int gridWidth, int gridHeight)
+		{
+			if (grid.CanStretchHorizontally && gridHeight >= gridWidth + itemWidth)
+			{
+				return new LocationInGrid(gridWidth, 0, ItemRotation.Horizontal);
+			}
+			if (grid.CanStretchVertically && (itemWidth <= gridWidth || grid.CanStretchHorizontally))
+			{
+				return new LocationInGrid(0, gridHeight, ItemRotation.Vertical);
+			}
+			return null;
+		}
+	}
+
+	private static string _logFilePath;
+
+	private static Type _itemFactoryType;
+
+	private static MethodInfo _createItemMethod;
+
+	private static object _singletonInstance;
+
+	static ItemFactory()
+	{
+		LoadItemFactoryType();
+	}
+
+	private static void LoadItemFactoryType()
+	{
+		Assembly assembly = Assembly.Load("Assembly-CSharp");
+		if (assembly == null)
+		{
+			return;
+		}
+		Type[] types = assembly.GetTypes();
+		foreach (Type type in types)
+		{
+			_createItemMethod = type.GetMethod("CreateItem", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+			if (_createItemMethod != null)
+			{
+				_itemFactoryType = type;
+				break;
+			}
+		}
+		if (!(_itemFactoryType == null))
+		{
+			PropertyInfo property = typeof(Singleton<>).MakeGenericType(_itemFactoryType).GetProperty("Instance", BindingFlags.Static | BindingFlags.Public);
+			if (property != null)
+			{
+				_singletonInstance = property.GetValue(null);
+			}
+		}
+	}
+
+	public Item CreateItem(string id)
+	{
+		if (_createItemMethod == null || _singletonInstance == null)
+		{
+			return null;
+		}
+		string text = MongoID.Generate();
+		object[] parameters = new object[3] { text, id, null };
+		object obj = _createItemMethod.Invoke(_singletonInstance, parameters);
+		if (obj != null)
+		{
+			return (Item)obj;
+		}
+		return null;
+	}
+
+	public Item CreateItemWithParent(string itemId, string parentId)
+	{
+		if (_createItemMethod == null || _singletonInstance == null)
+		{
+			return null;
+		}
+		string text = ((!string.IsNullOrEmpty(parentId)) ? parentId : ((string)MongoID.Generate()));
+		object[] parameters = new object[3] { text, itemId, null };
+		object obj = _createItemMethod.Invoke(_singletonInstance, parameters);
+		if (obj != null)
+		{
+			return (Item)obj;
+		}
+		return null;
+	}
+
+	public static void Log(string message)
+	{
+		_logFilePath = Path.Combine(Application.persistentDataPath, "log.txt");
+		using StreamWriter streamWriter = new StreamWriter(_logFilePath, append: true);
+		streamWriter.WriteLine($"{DateTime.Now}: {message}");
+	}
+}