using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using Auxilaryfunction;
using Auxilaryfunction.Models;
using Auxilaryfunction.Services;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using BuildToolOpt;
using DSPAllPlanetInfo;
using DSPBigInventory;
using HarmonyLib;
using LaserClearing;
using MassRecipePaste;
using Microsoft.CodeAnalysis;
using ModsPatch.BigInventory;
using MoreMegaStructure;
using Multifunction_mod;
using Multifunction_mod.GameModify;
using PlanetFinderMod;
using UXAssist;
using UXAssist.Common.ModCompat;
using UXAssist.ModsCompat;
using UXAssist.Patches.Logistics;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyFileVersion("1.0.1.0")]
[assembly: AssemblyInformationalVersion("1.0.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.1.0")]
[module: UnverifiableCode]
[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 ModsPatch
{
	public static class AllPlanetInfoFixes
	{
		public const string Target = "Appun.DSP.plugin.AllPlanetInfo";

		public static bool AlreadyFixed()
		{
			return AccessTools.Field(typeof(InfoCreater), "startSlotNo") != null;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Hook), "UIStarDetail_Prefix")]
		private static bool NoHistoryPrefix(ref int __state, ref bool __result)
		{
			if (GameMain.history != null)
			{
				return true;
			}
			__state = -1;
			__result = true;
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Hook), "UIStarDetail_Postfix")]
		private static bool NoHistoryPostfix(int __state)
		{
			if (__state >= 0)
			{
				return GameMain.history != null;
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPriority(800)]
		[HarmonyPatch(typeof(UIStarDetail), "OnStarDataSet")]
		[HarmonyPatch(typeof(UIStarDetail), "RefreshDynamicProperties")]
		[HarmonyPatch(typeof(UIPlanetDetail), "OnPlanetDataSet")]
		[HarmonyPatch(typeof(UIPlanetDetail), "RefreshDynamicProperties")]
		[HarmonyPatch(typeof(UIStarmap), "OnCursorFunction2Click")]
		[HarmonyPatch(typeof(UIStarmap), "OnStarClick")]
		private static void RememberLevel(out int __state)
		{
			__state = GameMain.history?.universeObserveLevel ?? (-1);
		}

		[HarmonyFinalizer]
		[HarmonyPatch(typeof(UIStarDetail), "OnStarDataSet")]
		[HarmonyPatch(typeof(UIStarDetail), "RefreshDynamicProperties")]
		[HarmonyPatch(typeof(UIPlanetDetail), "OnPlanetDataSet")]
		[HarmonyPatch(typeof(UIPlanetDetail), "RefreshDynamicProperties")]
		[HarmonyPatch(typeof(UIStarmap), "OnCursorFunction2Click")]
		[HarmonyPatch(typeof(UIStarmap), "OnStarClick")]
		private static Exception RestoreLevel(int __state, Exception __exception)
		{
			if (__state >= 0 && GameMain.history != null)
			{
				GameMain.history.universeObserveLevel = __state;
			}
			return __exception;
		}
	}
	public static class AuxilaryfunctionFixes
	{
		public const string Target = "cn.blacksnipe.dsp.Auxilaryfunction";

		public static bool AlreadyFixed()
		{
			return typeof(Auxilaryfunction).Assembly.GetType("Auxilaryfunction.NativeInventory") != null;
		}

		public static int Missing(int capacity, int idle, int working, int target)
		{
			return (int)Math.Max(0L, Math.Min((long)Math.Max(0, capacity), (long)Math.Max(0, target)) - Math.Max(0L, idle) - Math.Max(0L, working));
		}

		private static bool HasItem(Player player, int itemId)
		{
			if (player == null || itemId <= 0)
			{
				return false;
			}
			if (player.package.GetItemCount(itemId) > 0 || (player.inhandItemId == itemId && player.inhandItemCount > 0))
			{
				return true;
			}
			DeliveryPackage deliveryPackage = player.deliveryPackage;
			if (deliveryPackage == null || !deliveryPackage.unlocked)
			{
				return false;
			}
			for (int i = 0; i < deliveryPackage.grids.Length; i++)
			{
				if (deliveryPackage.IsGridActive(i) && deliveryPackage.grids[i].itemId == itemId && deliveryPackage.grids[i].count > 0)
				{
					return true;
				}
			}
			return false;
		}

		private static int Take(Player player, int itemId, int requested)
		{
			if (((player != null) ? player.packageUtility : null) == null || requested <= 0)
			{
				return 0;
			}
			int result = requested;
			int num = default(int);
			player.packageUtility.TryTakeItemFromAllPackages(ref itemId, ref result, ref num, true);
			return result;
		}

		private static int Take(Player player, int itemId, int requested, out int inc)
		{
			inc = 0;
			if (((player != null) ? player.packageUtility : null) == null || requested <= 0)
			{
				return 0;
			}
			int result = requested;
			player.packageUtility.TryTakeItemFromAllPackages(ref itemId, ref result, ref inc, true);
			return result;
		}

		private static void FillFuel(Player player, PlanetFactory factory, int generatorId, int itemId, int target)
		{
			if (player == null || player.factory != factory || factory?.powerSystem == null || generatorId <= 0 || generatorId >= factory.powerSystem.genCursor)
			{
				return;
			}
			ref PowerGeneratorComponent reference = ref factory.powerSystem.genPool[generatorId];
			ItemProto val = ((ProtoSet<ItemProto>)(object)LDB.items).Select(itemId);
			if (target <= reference.fuelCount || reference.id != generatorId || reference.fuelMask != 4 || val == null || itemId > 32767 || val.HeatValue <= 0 || (val.FuelType & reference.fuelMask) == 0 || (reference.fuelCount > 0 && reference.fuelId != itemId))
			{
				return;
			}
			int requested = Math.Min(Math.Max(0, target - reference.fuelCount), Math.Min(32767 - reference.fuelCount, (32767 - reference.fuelInc) / 10));
			int inc;
			int num = Take(player, itemId, requested, out inc);
			if (num > 0)
			{
				if (reference.fuelCount == 0)
				{
					((PowerGeneratorComponent)(ref reference)).SetNewFuel(itemId, (short)num, (short)inc);
					return;
				}
				reference.fuelCount += (short)num;
				reference.fuelInc += (short)inc;
			}
		}

		private static bool Own(PlanetFactory factory)
		{
			if (Auxilaryfunction.player != null && factory != null)
			{
				return Auxilaryfunction.player.factory == factory;
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(AuxilaryfunctionPatch), "NewGeneratorComponentPatch")]
		private static bool NewGenerator(ref int __0, PowerSystem __1)
		{
			if (Own(__1.factory) && AuxConfig.autosetSomevalue_bool.Value)
			{
				FillFuel(Auxilaryfunction.player, __1.factory, __0, AuxConfig.auto_supply_starfuelID.Value, AuxConfig.auto_supply_starfuel.Value);
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(AuxilaryfunctionPatch), "NewStationComponentPatch")]
		private static bool NewStation(ref StationComponent __0, PlanetTransport __1)
		{
			StationComponent val = __0;
			if (val == null || !Own(__1.factory))
			{
				return false;
			}
			Player player = Auxilaryfunction.player;
			if (AuxConfig.auto_supply_station.Value && !val.isCollector && !val.isVeinCollector)
			{
				if (BuildTargetValues.IsConfigEnabled("填充飞机数量"))
				{
					int idleDroneCount = val.idleDroneCount;
					DroneData[] workDroneDatas = val.workDroneDatas;
					val.idleDroneCount = idleDroneCount + Take(player, 5001, Missing((workDroneDatas != null) ? workDroneDatas.Length : 0, val.idleDroneCount, val.workDroneCount, AuxConfig.auto_supply_drone.Value));
				}
				if (BuildTargetValues.IsConfigEnabled("运输机最远路程"))
				{
					val.tripRangeDrones = Math.Cos((double)AuxConfig.stationdronedist.Value * Math.PI / 180.0);
				}
				if (BuildTargetValues.IsConfigEnabled("最大充电功率"))
				{
					long workEnergyPerTick = (long)AuxConfig.stationmaxpowerpertick.Value * 16667;
					if (AuxConfig.stationmaxpowerpertick.Value > 60f && !val.isStellar)
					{
						workEnergyPerTick = 1000020L;
					}
					__1.planet.factory.powerSystem.consumerPool[val.pcId].workEnergyPerTick = workEnergyPerTick;
				}
				if (BuildTargetValues.IsConfigEnabled("运输机起送量"))
				{
					val.deliveryDrones = ((AuxConfig.DroneStartCarry.Value == 0f) ? 1 : ((int)(AuxConfig.DroneStartCarry.Value * 10f) * 10));
				}
				if (val.isStellar)
				{
					if (BuildTargetValues.IsConfigEnabled("翘曲填充数量"))
					{
						val.warperCount += Take(player, 1210, Missing(int.MaxValue, val.warperCount, 0, AuxConfig.auto_supply_warp.Value));
					}
					if (BuildTargetValues.IsConfigEnabled("曲速启用路程"))
					{
						val.warpEnableDist = AuxConfig.stationwarpdist.Value * 40000.0;
					}
					if (BuildTargetValues.IsConfigEnabled("运输船起送量"))
					{
						val.deliveryShips = ((AuxConfig.ShipStartCarry.Value == 0f) ? 1 : ((int)(AuxConfig.ShipStartCarry.Value * 10f) * 10));
					}
					if (BuildTargetValues.IsConfigEnabled("填充飞船数量"))
					{
						int idleShipCount = val.idleShipCount;
						ShipData[] workShipDatas = val.workShipDatas;
						val.idleShipCount = idleShipCount + Take(player, 5002, Missing(Math.Min(64, (workShipDatas != null) ? workShipDatas.Length : 0), val.idleShipCount, val.workShipCount, AuxConfig.auto_supply_ship.Value));
					}
					if (BuildTargetValues.IsConfigEnabled("运输船最远路程"))
					{
						val.tripRangeShips = ((AuxConfig.stationshipdist.Value > 60) ? 24000000000L : ((long)AuxConfig.stationshipdist.Value * 2400000L));
					}
				}
			}
			if (AuxConfig.auto_supply_station.Value && val.isVeinCollector && BuildTargetValues.IsConfigEnabled("大型采矿机采矿速率"))
			{
				__1.factory.factorySystem.minerPool[val.minerId].speed = AuxConfig.veincollectorspeed.Value * 1000;
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(AuxilaryfunctionPatch), "NewDispenserComponentPatch")]
		private static bool NewDispenser(int __0, PlanetTransport __1)
		{
			if (__0 <= 0 || !Own(__1.factory) || !AuxConfig.autosetCourier_bool.Value || !BuildTargetValues.IsConfigEnabled("填充配送机数量"))
			{
				return false;
			}
			DispenserComponent val = __1.dispenserPool[__0];
			if (val != null)
			{
				int idleCourierCount = val.idleCourierCount;
				Player player = Auxilaryfunction.player;
				CourierData[] workCourierDatas = val.workCourierDatas;
				int val2 = ((workCourierDatas != null) ? workCourierDatas.Length : 0);
				DeliveryLogisticOrder[] orders = val.orders;
				val.idleCourierCount = idleCourierCount + Take(player, 5003, Missing(Math.Min(val2, (orders != null) ? orders.Length : 0), val.idleCourierCount, val.workCourierCount, AuxConfig.auto_supply_Courier.Value));
			}
			return false;
		}

		private static PlanetFactory OwnLocalFactory()
		{
			PlanetFactory val = AuxConfig.LocalPlanet?.factory;
			if (!Own(val))
			{
				return null;
			}
			return val;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(LogisticsService), "AddCourierToAllStar")]
		private static bool AddCourierToAllStar()
		{
			PlanetFactory val = OwnLocalFactory();
			if (val == null || !BuildTargetValues.IsConfigEnabled("填充配送机数量"))
			{
				return false;
			}
			DispenserComponent[] dispenserPool = val.transport.dispenserPool;
			foreach (DispenserComponent val2 in dispenserPool)
			{
				if (val2 != null && val2.id > 0)
				{
					CourierData[] workCourierDatas = val2.workCourierDatas;
					int val3 = ((workCourierDatas != null) ? workCourierDatas.Length : 0);
					DeliveryLogisticOrder[] orders = val2.orders;
					int num = Missing(Math.Min(val3, (orders != null) ? orders.Length : 0), val2.idleCourierCount, val2.workCourierCount, AuxConfig.auto_supply_Courier.Value);
					if (num > 0)
					{
						val2.idleCourierCount += Take(Auxilaryfunction.player, 5003, num);
					}
				}
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(LogisticsService), "AddDroneShipToStation")]
		private static bool AddDroneShipToStation()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			PlanetFactory val = OwnLocalFactory();
			if (val == null || (int)AuxConfig.LocalPlanet.type == 5)
			{
				return false;
			}
			bool flag = BuildTargetValues.IsConfigEnabled("填充飞机数量");
			bool flag2 = BuildTargetValues.IsConfigEnabled("填充飞船数量");
			bool flag3 = BuildTargetValues.IsConfigEnabled("翘曲填充数量");
			StationComponent[] stationPool = val.transport.stationPool;
			foreach (StationComponent val2 in stationPool)
			{
				if (val2 == null || val2.isVeinCollector)
				{
					continue;
				}
				if (flag)
				{
					DroneData[] workDroneDatas = val2.workDroneDatas;
					int num = Missing((workDroneDatas != null) ? workDroneDatas.Length : 0, val2.idleDroneCount, val2.workDroneCount, AuxConfig.auto_supply_drone.Value);
					if (num > 0)
					{
						val2.idleDroneCount += Take(Auxilaryfunction.player, 5001, num);
					}
				}
				if (flag2 && val2.isStellar)
				{
					ShipData[] workShipDatas = val2.workShipDatas;
					int num2 = Missing(Math.Min(64, (workShipDatas != null) ? workShipDatas.Length : 0), val2.idleShipCount, val2.workShipCount, AuxConfig.auto_supply_ship.Value);
					if (num2 > 0)
					{
						val2.idleShipCount += Take(Auxilaryfunction.player, 5002, num2);
					}
				}
				if (flag3)
				{
					int num3 = Missing(int.MaxValue, val2.warperCount, 0, AuxConfig.auto_supply_warp.Value);
					if (num3 > 0)
					{
						val2.warperCount += Take(Auxilaryfunction.player, 1210, num3);
					}
				}
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(LogisticsService), "AddFuelToAllStar")]
		private static bool AddFuelToAllStar()
		{
			PlanetFactory val = OwnLocalFactory();
			if (val?.powerSystem == null)
			{
				return false;
			}
			for (int i = 1; i < val.powerSystem.genCursor; i++)
			{
				FillFuel(Auxilaryfunction.player, val, i, AuxConfig.auto_supply_starfuelID.Value, AuxConfig.auto_supply_starfuel.Value);
			}
			return false;
		}

		[HarmonyTranspiler]
		[HarmonyPatch(typeof(Auxilaryfunction), "AutoMovetounbuilt")]
		private static IEnumerable<CodeInstruction> AutoMove(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo getCount = AccessTools.Method(typeof(StorageComponent), "GetItemCount", new Type[1] { typeof(int) }, (Type[])null);
			int n = 0;
			foreach (CodeInstruction instruction in instructions)
			{
				if (CodeInstructionExtensions.Calls(instruction, getCount))
				{
					instruction.opcode = OpCodes.Call;
					instruction.operand = AccessTools.Method(typeof(AuxilaryfunctionFixes), "PlayerItemCount", (Type[])null, (Type[])null);
					n++;
				}
				yield return instruction;
			}
			Il.Require(n == 2, "Auxilaryfunction AutoMovetounbuilt GetItemCount x2");
		}

		private static int PlayerItemCount(StorageComponent package, int itemId)
		{
			Player mainPlayer = GameMain.mainPlayer;
			if (mainPlayer != null && package == mainPlayer.package)
			{
				return HasItem(mainPlayer, itemId) ? 1 : 0;
			}
			return package.GetItemCount(itemId);
		}
	}
	public static class BigInventoryFixes
	{
		public const string Target = "Appun.DSP.plugin.BigInventory";

		public static bool AlreadyFixed()
		{
			return typeof(DSPBigInventory).Assembly.GetType("DSPBigInventory.ScreenLimits") != null;
		}

		[HarmonyPrepare]
		private static void Prepare(MethodBase original)
		{
			if (original == null)
			{
				ScreenLimits.Active = true;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(DSPBigInventory), "Mecha_Import_Postfix")]
		[HarmonyPatch(typeof(DSPBigInventory), "Mecha_SetForNewGame_Postfix")]
		[HarmonyPatch(typeof(DSPBigInventory), "UIInventoryWindow_OnPackageSizeChange_Postfix")]
		private static bool Skip()
		{
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(DSPBigInventory), "GameHistoryData_UnlockTechFunction_Prefix")]
		private static bool AllowResearch(ref bool __result)
		{
			__result = true;
			return false;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Player), "Import")]
		[HarmonyPatch(typeof(Player), "SetForNewGame")]
		private static void Loaded(Player __instance)
		{
			Apply(__instance);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(GameHistoryData), "UnlockTechFunction")]
		private static void Researched(int func)
		{
			if (func == 5 || func == 32 || func == 38)
			{
				Apply(GameMain.mainPlayer);
			}
		}

		private static void Apply(Player player)
		{
			Apply(player, DSPBigInventory.colCount?.Value ?? 16, DSPBigInventory.rowCount?.Value ?? 14, DSPBigInventory.DeliveryColCount?.Value ?? 5, DSPBigInventory.defaultSetting?.Value ?? false);
		}

		private static int Clamp(int value, int min, int max)
		{
			return Math.Max(min, Math.Min(max, value));
		}

		public static void UsedBounds(StorageComponent package, int columns, out int usedColumns, out int usedRows)
		{
			usedColumns = 0;
			usedRows = 0;
			for (int i = 0; i < package.size; i++)
			{
				if (package.grids[i].itemId != 0 || package.grids[i].count != 0 || package.grids[i].filter != 0)
				{
					usedRows = Math.Max(usedRows, i / columns + 1);
					usedColumns = Math.Max(usedColumns, i % columns + 1);
				}
			}
		}

		public static void Plan(int configColumns, int configRows, int oldColumns, int oldSize, int usedColumns, int usedRows, int deliveryColumns, out int columns, out int rows)
		{
			configColumns = Clamp(configColumns, 10, 30);
			configRows = Clamp(configRows, 1, 100);
			int num = (oldSize - 1) / oldColumns + 1;
			int num2 = Math.Max(10, usedColumns);
			int num3 = Math.Max(ScreenLimits.MaxColumns(deliveryColumns), num2);
			int num4 = Clamp(oldColumns, num2, num3);
			int num5 = Clamp(Math.Max(configColumns, num4), num4, num3);
			int num6 = Math.Max(configRows, num);
			int[] array = new int[4] { num5, num4, num5, num4 };
			int[] array2 = new int[4] { num6, num6, num, num };
			for (int i = 0; i < array.Length; i++)
			{
				if (Acceptable(array[i], array2[i], oldSize, usedColumns, usedRows, deliveryColumns))
				{
					columns = array[i];
					rows = array2[i];
					return;
				}
			}
			long num7 = Math.Max(oldSize, (long)num4 * (long)configRows);
			for (int j = num4; j <= num3; j++)
			{
				int num8 = (int)Math.Max(usedRows, (num7 + j - 1) / j);
				if (Acceptable(j, num8, oldSize, usedColumns, usedRows, deliveryColumns))
				{
					columns = j;
					rows = num8;
					return;
				}
			}
			columns = num4;
			rows = Math.Max(ScreenLimits.MaxRows(num4, deliveryColumns), usedRows);
		}

		private static bool Acceptable(int columns, int rows, int oldSize, int usedColumns, int usedRows, int deliveryColumns)
		{
			if (columns >= usedColumns && rows >= usedRows && rows <= Math.Max(ScreenLimits.MaxRows(columns, deliveryColumns), usedRows))
			{
				return (long)columns * (long)rows <= Math.Max(400, oldSize);
			}
			return false;
		}

		public static bool Relayout(Player player, int newColumns, int newRows)
		{
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			StorageComponent package = player.package;
			int packageColumnCount = player.GetPackageColumnCount();
			long num = (long)newColumns * (long)newRows;
			if (newColumns < 1 || newRows < 1 || num > int.MaxValue)
			{
				return false;
			}
			for (int i = 0; i < package.size; i++)
			{
				if ((i / packageColumnCount >= newRows || i % packageColumnCount >= newColumns) && (package.grids[i].itemId != 0 || package.grids[i].count != 0 || package.grids[i].filter != 0))
				{
					return false;
				}
			}
			GRID[] array = (GRID[])(object)new GRID[(int)num];
			for (int j = 0; j < package.size; j++)
			{
				if (j / packageColumnCount < newRows && j % packageColumnCount < newColumns)
				{
					array[j / packageColumnCount * newColumns + j % packageColumnCount] = package.grids[j];
				}
			}
			player.packageColCount = newColumns;
			package.grids = array;
			package.size = (int)num;
			package.ResetOptimizationFlags();
			package.NotifyStorageChange();
			package.NotifyStorageSizeChange();
			return true;
		}

		public static void Apply(Player player, int columns, int rows, int deliveryColumns, bool native)
		{
			if (native || ((player != null) ? player.package : null) == null)
			{
				return;
			}
			deliveryColumns = Clamp(deliveryColumns, 0, 5);
			int packageColumnCount = player.GetPackageColumnCount();
			int size = player.package.size;
			int num = (size - 1) / packageColumnCount + 1;
			int deliveryColumns2 = ((player.deliveryPackage != null) ? Math.Max(player.deliveryPackage.colCount, deliveryColumns) : deliveryColumns);
			UsedBounds(player.package, packageColumnCount, out var usedColumns, out var usedRows);
			Plan(columns, rows, packageColumnCount, size, usedColumns, usedRows, deliveryColumns2, out var columns2, out var rows2);
			int num2 = checked(columns2 * rows2);
			if (columns2 >= packageColumnCount && rows2 >= num)
			{
				player.packageColCount = columns2;
				if (columns2 != packageColumnCount)
				{
					player.package.SetSize(num2, packageColumnCount, columns2);
				}
				else if (player.package.size < num2)
				{
					player.package.SetSize(num2);
				}
			}
			else if (!Relayout(player, columns2, rows2))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("BigInventory: inventory " + packageColumnCount + "x" + num + " kept, it holds items outside " + columns2 + "x" + rows2));
				}
			}
			if (columns2 != packageColumnCount || rows2 != num)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogInfo((object)("BigInventory: inventory " + packageColumnCount + "x" + num + " -> " + player.GetPackageColumnCount() + "x" + ((player.package.size - 1) / player.GetPackageColumnCount() + 1) + " (" + ScreenLimits.Describe(deliveryColumns2, columns2) + ")"));
				}
			}
			if (player.deliveryPackage != null)
			{
				player.deliveryPackage.colCount = Math.Max(player.deliveryPackage.colCount, deliveryColumns);
				player.OnPackageSizeChange();
			}
		}
	}
	public static class BuildToolOptFixes
	{
		public const string Target = "starfi5h.plugin.BuildToolOpt";

		private static PlanetTransport replacingTransport;

		private static int replacingStationId;

		public static bool AlreadyFixed()
		{
			return AccessTools.Field(typeof(ReplaceStationLogic), "replacingTransport") != null;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ReplaceStationLogic), "TakeBackItems_Station")]
		private static bool TakeBack(PlanetTransport __0, int __1, ref bool __2)
		{
			if (!__2 || !ReplaceStationLogic.IsReplacing || ReplaceStationLogic.ReplacingGhost || __0 != replacingTransport || __1 != replacingStationId)
			{
				return false;
			}
			__2 = false;
			StationComponent val = ((__1 == 0) ? null : __0.GetStationComponent(__1));
			if (val == null || val.id != __1)
			{
				return false;
			}
			if (val.storage != null)
			{
				for (int i = 0; i < val.storage.Length; i++)
				{
					if (val.storage[i].count > 0 && val.storage[i].itemId > 0)
					{
						val.storage[i].count = 0;
						val.storage[i].inc = 0;
					}
				}
			}
			val.idleDroneCount = 0;
			val.idleShipCount = 0;
			val.warperCount = 0;
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ReplaceStationLogic), "ReplaceStation")]
		private static void ReplaceStationStart(BuildTool_Click tool, int stationId)
		{
			replacingTransport = ((BuildTool)tool).factory.transport;
			replacingStationId = stationId;
		}

		[HarmonyFinalizer]
		[HarmonyPatch(typeof(ReplaceStationLogic), "ReplaceStation")]
		private static void ReplaceStationEnd()
		{
			ReplaceStationLogic.ReplacingGhost = false;
			ReplaceStationLogic.IsReplacing = false;
			replacingTransport = null;
			replacingStationId = 0;
		}

		[HarmonyFinalizer]
		[HarmonyPatch(typeof(ReplaceStationLogic), "ReplaceStationPrebuild")]
		private static void ReplacePrebuildEnd()
		{
			ReplaceStationLogic.ReplacingGhost = false;
			ReplaceStationLogic.IsReplacing = false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ReplaceStationLogic), "GetOverlapStationEntityId")]
		private static bool OverlapEntity(BuildTool_Click tool, ref int __result)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			__result = 0;
			PlanetPhysics physics = ((BuildTool)tool).player.planetData.physics;
			Collider[] tmp_cols = BuildTool._tmp_cols;
			ColliderData val = default(ColliderData);
			for (int i = 0; i < tmp_cols.Length && (Object)(object)tmp_cols[i] != (Object)null; i++)
			{
				if (physics.GetColliderData(tmp_cols[i], ref val) && (int)((ColliderData)(ref val)).objType == 0 && ((BuildTool)tool).factory.entityPool[((ColliderData)(ref val)).objId].stationId > 0)
				{
					__result = ((ColliderData)(ref val)).objId;
					break;
				}
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ReplaceStationLogic), "GetOverlapStationPrebuildId")]
		private static bool OverlapPrebuild(BuildTool_Click tool, ref int __result)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Invalid comparison between Unknown and I4
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: 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)
			__result = 0;
			PlanetPhysics physics = ((BuildTool)tool).player.planetData.physics;
			Collider[] tmp_cols = BuildTool._tmp_cols;
			ColliderData val = default(ColliderData);
			for (int i = 0; i < tmp_cols.Length && (Object)(object)tmp_cols[i] != (Object)null; i++)
			{
				if (!physics.GetColliderData(tmp_cols[i], ref val) || (int)((ColliderData)(ref val)).objType != 3)
				{
					continue;
				}
				PrebuildData val2 = ((BuildTool)tool).factory.prebuildPool[((ColliderData)(ref val)).objId];
				if (val2.id == ((ColliderData)(ref val)).objId)
				{
					ItemProto val3 = ((ProtoSet<ItemProto>)(object)LDB.items).Select((int)val2.protoId);
					if (val3 != null && val3.prefabDesc.isStation && !val3.prefabDesc.isVeinCollector && !val3.prefabDesc.isCollectStation)
					{
						__result = ((ColliderData)(ref val)).objId;
						break;
					}
				}
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ReplaceStationLogic), "LoadState")]
		private static bool LoadState(StationComponent station, ref StationState state)
		{
			station.energy = state.energy;
			station.warperCount = MergeStock(state.warperCount, station.warperCount, station.warperMaxCount, out var excess);
			ReplaceStationLogic.RefundItem(1210, excess, 0, station.entityId);
			int droneCount = state.droneCount;
			int idleDroneCount = station.idleDroneCount;
			DroneData[] workDroneDatas = station.workDroneDatas;
			station.idleDroneCount = MergeStock(droneCount, idleDroneCount, Math.Max(0, ((workDroneDatas != null) ? workDroneDatas.Length : 0) - station.workDroneCount), out excess);
			ReplaceStationLogic.RefundItem(5001, excess, 0, station.entityId);
			int shipCount = state.shipCount;
			int idleShipCount = station.idleShipCount;
			ShipData[] workShipDatas = station.workShipDatas;
			station.idleShipCount = MergeStock(shipCount, idleShipCount, Math.Max(0, Math.Min(64, (workShipDatas != null) ? workShipDatas.Length : 0) - station.workShipCount), out excess);
			ReplaceStationLogic.RefundItem(5002, excess, 0, station.entityId);
			int num = Math.Min(station.storage.Length, state.storage.Length);
			for (int i = 0; i < num; i++)
			{
				station.storage[i].count = state.storage[i].count;
				station.storage[i].inc = state.storage[i].inc;
			}
			for (int j = num; j < state.storage.Length; j++)
			{
				ReplaceStationLogic.RefundItem(state.storage[j].itemId, state.storage[j].count, state.storage[j].inc, station.entityId);
			}
			return false;
		}

		public static int MergeStock(int saved, int added, int capacity, out int excess)
		{
			long num = (long)Math.Max(0, saved) + (long)Math.Max(0, added);
			int num2 = (int)Math.Min(num, Math.Max(0, capacity));
			excess = (int)Math.Min(2147483647L, num - num2);
			return num2;
		}
	}
	public static class LaserClearingFixes
	{
		public const string Target = "starfi5h.plugin.LaserClearing";

		private static readonly List<int> laserIds = new List<int>();

		private static readonly Dictionary<int, int> laserTargets = new Dictionary<int, int>();

		private static PlanetFactory ownerFactory;

		private static SkillSystem ownerSkillSystem;

		[ThreadStatic]
		private static bool enemyKill;

		public static bool AlreadyFixed()
		{
			return AccessTools.Field(typeof(LocalLaser_Patch), "laserTargets") != null;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(LocalLaser_Patch), "GameTick")]
		private static bool GameTick(PlayerAction_Mine __0)
		{
			//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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: 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)
			if (!LocalLaser_Patch.Enable)
			{
				return false;
			}
			PlanetFactory factory = ((PlayerAction)__0).player.factory;
			if (factory == null)
			{
				ClearAll();
				return false;
			}
			if (ownerFactory != factory)
			{
				ClearAll();
			}
			if (!LocalLaser_Patch.CheckPlayerInventorySpace())
			{
				ClearAll();
				UI_Patch.UpdateButtonStatus((ButtonStatus)2);
				return false;
			}
			UI_Patch.UpdateButtonStatus((ButtonStatus)1);
			ownerFactory = factory;
			Mecha mecha = ((PlayerAction)__0).player.mecha;
			Vector3 skillCastRightL = mecha.skillCastRightL;
			if (laserIds.Count < LocalLaser_Patch.maxLaserCount && GameMain.gameTick % LocalLaser_Patch.checkIntervalTick == 0L)
			{
				int num = ClosestPlant(factory, skillCastRightL, LocalLaser_Patch.Range);
				if (num != 0)
				{
					laserIds.Add(StartLaser(factory, num, skillCastRightL));
				}
			}
			for (int num2 = laserIds.Count - 1; num2 >= 0; num2--)
			{
				if (!ContinueLaser(factory, laserIds[num2], skillCastRightL, mecha))
				{
					laserTargets.Remove(laserIds[num2]);
					laserIds.RemoveAt(num2);
				}
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(LocalLaser_Patch), "ClearAll")]
		private static bool ClearAll()
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Invalid comparison between Unknown and I4
			if (ownerSkillSystem != null && ownerFactory != null)
			{
				ref DataPoolRenderer<LocalLaserContinuous> localLaserContinuous = ref ownerSkillSystem.localLaserContinuous;
				if (localLaserContinuous?.buffer != null)
				{
					foreach (int laserId in laserIds)
					{
						if (laserId > 0 && laserId < localLaserContinuous.cursor && laserId < localLaserContinuous.buffer.Length)
						{
							ref LocalLaserContinuous reference = ref localLaserContinuous.buffer[laserId];
							if (reference.id == laserId && reference.astroId == ownerFactory.planetId && (int)reference.target.type == 1 && laserTargets.TryGetValue(laserId, out var value) && reference.target.id == value)
							{
								((LocalLaserContinuous)(ref reference)).Stop(ownerSkillSystem);
							}
						}
					}
				}
			}
			laserIds.Clear();
			laserTargets.Clear();
			ownerFactory = null;
			ownerSkillSystem = null;
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPriority(800)]
		[HarmonyPatch(typeof(PlanetFactory), "KillVegeFinally")]
		private static void MarkCaster(ref CombatStat combatStat)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			enemyKill = (int)combatStat.lastCaster.type == 4;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(LocalLaser_Patch), "KillVegeFinally_Prefix")]
		private static bool KillVege(PlanetFactory __0, int id, ref bool __result)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			__result = true;
			if (enemyKill || !LocalLaser_Patch.Enable || __0 != ownerFactory || !laserTargets.ContainsValue(id))
			{
				return false;
			}
			if (id <= 0 || id >= __0.vegePool.Length || __0.vegePool[id].id != id)
			{
				return false;
			}
			ref VegeData reference = ref __0.vegePool[id];
			VegeProto val = ((ProtoSet<VegeProto>)(object)LDB.veges).Select((int)reference.protoId);
			if (val != null)
			{
				VFEffectEmitter.Emit(val.MiningEffect, reference.pos, reference.rot);
				if (LocalLaser_Patch.EnableDestructionSFX)
				{
					VFAudio.Create(val.MiningAudio, (Transform)null, reference.pos, true, 1, -1, -1L);
				}
				if (LocalLaser_Patch.EnableLoot)
				{
					LocalLaser_Patch.GetVegLoot(__0, ref reference, val);
				}
			}
			__0.gameData.mainPlayer.vegetableCollection.AddVegeToPlayer((int)reference.protoId, 1);
			__0.RemoveVegeWithComponents(id);
			__result = false;
			return false;
		}

		private static int StartLaser(PlanetFactory factory, int vegeId, Vector3 beginPos)
		{
			//IL_004c: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			ownerSkillSystem = GameMain.data.spaceSector.skillSystem;
			ref LocalLaserContinuous reference = ref ownerSkillSystem.localLaserContinuous.Add();
			ref VegeData reference2 = ref factory.vegePool[vegeId];
			((LocalLaserContinuous)(ref reference)).Start();
			reference.astroId = factory.planetId;
			reference.hitIndex = 4;
			reference.beginPos = reference2.pos + ((Vector3)(ref reference2.pos)).normalized * SkillSystem.RoughHeightByModelIndex[reference2.modelIndex] * 0.5f;
			reference.endPos = beginPos;
			reference.target.type = (ETargetType)1;
			reference.target.id = vegeId;
			int num = SkillSystem.HpMaxByModelIndex[reference2.modelIndex];
			int num2 = SkillSystem.HpRecoverByModelIndex[reference2.modelIndex];
			reference.damage = (int)((float)(num / LocalLaser_Patch.tickToClear + num2) / 1f + 1f);
			reference.damageScale = 1f;
			reference.mask = (ETargetTypeMask)127;
			reference.sfxId = ownerSkillSystem.audio.AddPlanetAudio(123, 0f, reference.astroId, reference.beginPos, 0).id;
			laserTargets[reference.id] = vegeId;
			return reference.id;
		}

		private static bool ContinueLaser(PlanetFactory factory, int laserId, Vector3 beginPos, Mecha mecha)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Invalid comparison between Unknown and I4
			//IL_009b: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: 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_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			if (ownerSkillSystem == null || factory != ownerFactory)
			{
				return false;
			}
			ref DataPoolRenderer<LocalLaserContinuous> localLaserContinuous = ref ownerSkillSystem.localLaserContinuous;
			if (localLaserContinuous?.buffer == null || laserId <= 0 || laserId >= localLaserContinuous.cursor || laserId >= localLaserContinuous.buffer.Length)
			{
				return false;
			}
			ref LocalLaserContinuous reference = ref localLaserContinuous.buffer[laserId];
			if (!laserTargets.TryGetValue(laserId, out var value) || reference.id != laserId || (int)reference.target.type != 1 || reference.target.id != value || reference.astroId != factory.planetId)
			{
				return false;
			}
			reference.endPos = beginPos;
			if (value <= 0 || value >= factory.vegePool.Length)
			{
				((LocalLaserContinuous)(ref reference)).Stop(ownerSkillSystem);
				return false;
			}
			ref VegeData reference2 = ref factory.vegePool[value];
			if (reference2.id == 0)
			{
				((LocalLaserContinuous)(ref reference)).Stop(ownerSkillSystem);
				return false;
			}
			reference.beginPos = reference2.pos + ((Vector3)(ref reference2.pos)).normalized * SkillSystem.RoughHeightByModelIndex[reference2.modelIndex] * 0.5f;
			if (Vector3.SqrMagnitude(reference2.pos - beginPos) > LocalLaser_Patch.Range * LocalLaser_Patch.Range)
			{
				((LocalLaserContinuous)(ref reference)).Stop(ownerSkillSystem);
				return false;
			}
			double num = default(double);
			float damageScale = default(float);
			mecha.QueryEnergy(LocalLaser_Patch.MiningPower, ref num, ref damageScale);
			mecha.coreEnergy -= num;
			mecha.MarkEnergyChange(5, 0.0 - num);
			reference.damageScale = damageScale;
			return true;
		}

		private static int ClosestPlant(PlanetFactory factory, Vector3 centerPos, float range)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			int result = 0;
			VegeData[] vegePool = factory.vegePool;
			float num = range * range;
			HashSystem hashSystemStatic = factory.hashSystemStatic;
			hashSystemStatic.ClearActiveBuckets();
			int[] hashPool = hashSystemStatic.hashPool;
			int[] bucketOffsets = hashSystemStatic.bucketOffsets;
			int[] bucketCursors = hashSystemStatic.bucketCursors;
			hashSystemStatic.GetBucketIdxesInArea(centerPos, range);
			int[] activeBuckets = hashSystemStatic.activeBuckets;
			for (int i = 0; i < hashSystemStatic.activeBucketsCount; i++)
			{
				int num2 = activeBuckets[i];
				int num3 = bucketOffsets[num2] + bucketCursors[num2];
				for (int j = bucketOffsets[num2]; j < num3; j++)
				{
					int num4 = hashPool[j];
					if (num4 == 0 || num4 >> 28 != 1)
					{
						continue;
					}
					int num5 = num4 & 0xFFFFFFF;
					if (num5 <= 0 || num5 >= vegePool.Length || laserTargets.ContainsValue(num5))
					{
						continue;
					}
					ref VegeData reference = ref vegePool[num5];
					if (reference.id != num5 || (reference.protoId == 9999 && !LocalLaser_Patch.SpaceCapsule))
					{
						continue;
					}
					VegeProto val = ((ProtoSet<VegeProto>)(object)LDB.veges).Select((int)reference.protoId);
					if (val != null && (!LocalLaser_Patch.DropOnly || (val.MiningItem != null && val.MiningItem.Length != 0)))
					{
						float num6 = Vector3.SqrMagnitude(reference.pos - centerPos);
						if (num6 < num)
						{
							result = num5;
							num = num6;
						}
					}
				}
			}
			hashSystemStatic.ClearActiveBuckets();
			return result;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(UI_Patch), "UpdateButtonStatus")]
		private static bool NoButton()
		{
			return (Object)(object)UI_Patch.enableButton != (Object)null;
		}
	}
	public static class MassRecipePasteFixes
	{
		public const string Target = "starfi5h.plugin.MassRecipePaste";

		public static bool AlreadyFixed()
		{
			return AccessTools.Method(typeof(Patches), "CountSuccessfulPaste", (Type[])null, (Type[])null) != null;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Patches), "Blocker")]
		private static bool Blocker(ref bool __result)
		{
			if (Patches.tool != null)
			{
				return true;
			}
			__result = true;
			return false;
		}
	}
	public static class MoreMegaStructureFixes
	{
		public const string Target = "Gnimaerd.DSP.plugin.MoreMegaStructure";

		public static bool AlreadyFixed()
		{
			return AccessTools.Method(typeof(UIStatisticsPatcher), "CalculatorFactoryPrefix", (Type[])null, (Type[])null) != null;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(UIStatisticsPatcher), "ProductionExtraInfoCalculator_GameTick_Prefix")]
		private static bool DisableOldGameTickPrefix(ref bool __result)
		{
			__result = true;
			return false;
		}

		public static PlanetFactory Lookup(GameData gameData, int factoryIndex)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			if (factoryIndex >= 0 && factoryIndex < gameData.factories.Length)
			{
				return gameData.factories[factoryIndex];
			}
			if (factoryIndex >= gameData.factories.Length + gameData.galaxy.starCount)
			{
				throw new ArgumentOutOfRangeException("factoryIndex");
			}
			PlanetFactory val = new PlanetFactory();
			AccessTools.Property(typeof(PlanetFactory), "index").SetValue(val, factoryIndex, null);
			return val;
		}

		[HarmonyTranspiler]
		[HarmonyPatch(typeof(ProductionExtraInfoCalculator), "GameTick")]
		private static IEnumerable<CodeInstruction> GameTick(IEnumerable<CodeInstruction> instructions)
		{
			return ReplaceFactoryLookup(instructions);
		}

		[HarmonyTranspiler]
		[HarmonyPatch(typeof(ProductionExtraInfoCalculator), "CalculateImmediately")]
		private static IEnumerable<CodeInstruction> CalculateImmediately(IEnumerable<CodeInstruction> instructions)
		{
			return ReplaceFactoryLookup(instructions);
		}

		private static IEnumerable<CodeInstruction> ReplaceFactoryLookup(IEnumerable<CodeInstruction> instructions)
		{
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			FieldInfo fieldInfo = AccessTools.Field(typeof(GameData), "factories");
			int num = 0;
			for (int i = 0; i + 2 < list.Count; i++)
			{
				if (CodeInstructionExtensions.LoadsField(list[i], fieldInfo, false) && CodeInstructionExtensions.IsLdloc(list[i + 1], (LocalBuilder)null) && !(list[i + 2].opcode != OpCodes.Ldelem_Ref))
				{
					list[i].opcode = OpCodes.Nop;
					list[i].operand = null;
					list[i + 2].opcode = OpCodes.Call;
					list[i + 2].operand = AccessTools.Method(typeof(MoreMegaStructureFixes), "Lookup", (Type[])null, (Type[])null);
					num++;
				}
			}
			Il.Require(num == 1, "ProductionExtraInfoCalculator factory lookup (" + num + ")");
			return list;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ProductionExtraInfoCalculator), "CalculateFactory")]
		private static bool CalculateFactory(ProductionExtraInfoCalculator __instance, GameData gameData, PlanetFactory factory)
		{
			if (factory == null || factory.index < gameData.factories.Length)
			{
				return true;
			}
			UIStatisticsPatcher.CalculateFactory_IA(ref __instance, gameData, factory.index);
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(UIStatisticsPatcher), "CalculateFactory_IA")]
		private static bool CalculateFactoryIA(ref ProductionExtraInfoCalculator __0, GameData gameData, int factoryIndex)
		{
			int num = UIStatisticsPatcher.FactoryIndex2StarIndex(factoryIndex);
			int[] starMegaStructureType = MoreMegaStructure.StarMegaStructureType;
			if (num >= 0 && num < starMegaStructureType.Length && starMegaStructureType[num] == 4 && gameData.dysonSpheres != null && num < gameData.dysonSpheres.Length && gameData.dysonSpheres[num] != null)
			{
				return true;
			}
			FactoryProductionStat obj = __0.productionStatistics.factoryStatPool[factoryIndex];
			obj.ResetRefSpeed();
			obj.ResetStorageCount();
			obj.ResetDetailedStorageCount();
			obj.ResetTransportStorageCount();
			return false;
		}
	}
	public static class MultifunctionFixes
	{
		private sealed class RecipeOrigin
		{
			public bool Handcraft;

			public int TimeSpend;

			public int CacheTimeSpend;

			public int CacheExtraTimeSpend;
		}

		public const string Target = "cn.blacksnipe.dsp.Multfuntion_mod";

		private static readonly Dictionary<RecipeProto, RecipeOrigin> recipeOrigins = new Dictionary<RecipeProto, RecipeOrigin>();

		public static bool AlreadyFixed()
		{
			return typeof(Multifunction).Assembly.GetType("Multifunction_mod.Patchs.PlanetReformCollectPatch") != null;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerModify), "OperatePackageSize")]
		private static bool OperatePackageSize(Player player, int rownum, int colnum, bool add)
		{
			ResizePackage(player, rownum, colnum, add);
			return false;
		}

		public static bool ResizePackage(Player target, int rowDelta, int columnDelta, bool add)
		{
			//IL_0171: 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)
			if (((target != null) ? target.package : null) == null || rowDelta < 0 || columnDelta < 0 || target.packageColCount <= 0)
			{
				return false;
			}
			StorageComponent package = target.package;
			int packageColCount = target.packageColCount;
			long num = ((long)package.size + (long)packageColCount - 1) / packageColCount;
			long num2 = Math.Max(10L, Math.Min(30L, packageColCount + (add ? columnDelta : (-columnDelta))));
			long num3 = Math.Max(1L, num + (add ? rowDelta : (-rowDelta)));
			if (add)
			{
				if (ScreenLimit("MaxColumnsNow", 0, out var limit))
				{
					num2 = Math.Min(num2, Math.Max(packageColCount, limit));
				}
				if (ScreenLimit("MaxRowsNow", (int)num2, out var limit2))
				{
					num3 = Math.Min(num3, Math.Max(num, limit2));
					if (num2 * num3 > package.size && num3 > limit2)
					{
						return false;
					}
				}
				if (num2 == packageColCount && num3 == num)
				{
					return false;
				}
			}
			long num4 = num3 * num2;
			if (num4 > int.MaxValue)
			{
				return false;
			}
			for (int i = 0; i < package.size; i++)
			{
				if ((i / packageColCount >= num3 || i % packageColCount >= num2) && (package.grids[i].count != 0 || package.grids[i].filter != 0))
				{
					return false;
				}
			}
			GRID[] array = (GRID[])(object)new GRID[(int)num4];
			for (int j = 0; j < package.size; j++)
			{
				if (j / packageColCount < num3 && j % packageColCount < num2)
				{
					array[j / packageColCount * (int)num2 + j % packageColCount] = package.grids[j];
				}
			}
			target.packageColCount = (int)num2;
			package.grids = array;
			package.size = (int)num4;
			package.ResetOptimizationFlags();
			package.NotifyStorageChange();
			package.NotifyStorageSizeChange();
			return true;
		}

		private static bool ScreenLimit(string name, int argument, out int limit)
		{
			if (ScreenLimits.Active)
			{
				limit = ((name == "MaxRowsNow") ? ScreenLimits.MaxRowsNow(argument) : ScreenLimits.MaxColumnsNow());
				return true;
			}
			limit = int.MaxValue;
			try
			{
				Type type = AccessTools.TypeByName("DSPBigInventory.ScreenLimits");
				bool flag = name == "MaxRowsNow";
				MethodInfo methodInfo = type?.GetMethod(name, (!flag) ? Type.EmptyTypes : new Type[1] { typeof(int) });
				if (methodInfo == null)
				{
					return false;
				}
				limit = (int)methodInfo.Invoke(null, (!flag) ? null : new object[1] { argument });
				return true;
			}
			catch (Exception)
			{
				return false;
			}
		}

		private static RecipeOrigin Origin(RecipeProto recipe)
		{
			if (!recipeOrigins.TryGetValue(recipe, out var value))
			{
				RecipeExecuteData recipeExecuteData = RecipeModify.GetRecipeExecuteData(recipe);
				value = new RecipeOrigin
				{
					Handcraft = recipe.Handcraft,
					TimeSpend = recipe.TimeSpend,
					CacheTimeSpend = (recipeExecuteData?.timeSpend ?? (recipe.TimeSpend * 10000)),
					CacheExtraTimeSpend = (recipeExecuteData?.extraTimeSpend ?? 0)
				};
				recipeOrigins.Add(recipe, value);
			}
			return value;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(RecipeModify), "CaptureRecipeOriginals")]
		private static bool CaptureRecipeOriginals()
		{
			if (((ProtoSet<RecipeProto>)(object)LDB.recipes)?.dataArray != null)
			{
				RecipeProto[] dataArray = ((ProtoSet<RecipeProto>)(object)LDB.recipes).dataArray;
				for (int i = 0; i < dataArray.Length; i++)
				{
					Origin(dataArray[i]);
				}
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(RecipeModify), "ApplyRecipeModifications")]
		private static bool ApplyRecipeModifications(bool allHandcraft, bool quickProduce)
		{
			if (((ProtoSet<RecipeProto>)(object)LDB.recipes)?.dataArray == null || recipeOrigins.Count == 0)
			{
				return false;
			}
			if (!allHandcraft && !quickProduce && !RecipeModify.recipeModificationsApplied)
			{
				return false;
			}
			RecipeModify.recipeModificationsApplied = allHandcraft || quickProduce;
			RecipeProto[] dataArray = ((ProtoSet<RecipeProto>)(object)LDB.recipes).dataArray;
			foreach (RecipeProto obj in dataArray)
			{
				RecipeOrigin recipeOrigin = Origin(obj);
				obj.Handcraft = allHandcraft || recipeOrigin.Handcraft;
				obj.TimeSpend = (quickProduce ? 10 : recipeOrigin.TimeSpend);
				RecipeExecuteData recipeExecuteData = RecipeModify.GetRecipeExecuteData(obj);
				if (recipeExecuteData != null && recipeOrigin.CacheTimeSpend > 0)
				{
					int num = (quickProduce ? 100000 : recipeOrigin.CacheTimeSpend);
					if (recipeOrigin.CacheExtraTimeSpend > 0)
					{
						RecipeModify.SetRecipeExecuteCycleTime(recipeExecuteData, num, (int?)(quickProduce ? RecipeModify.ScaleCycleTime(recipeOrigin.CacheExtraTimeSpend, recipeOrigin.CacheTimeSpend, num) : recipeOrigin.CacheExtraTimeSpend));
					}
					else
					{
						RecipeModify.SetRecipeExecuteCycleTime(recipeExecuteData, num, (int?)null);
					}
				}
			}
			RebuildHandcraftCache();
			return false;
		}

		private static void RebuildHandcraftCache()
		{
			ItemProto[] dataArray = ((ProtoSet<ItemProto>)(object)LDB.items).dataArray;
			foreach (ItemProto val in dataArray)
			{
				RecipeProto handcraft = val.handcraft;
				if (val.handcrafts == null)
				{
					val.handcrafts = new List<RecipeProto>();
				}
				else
				{
					val.handcrafts.Clear();
				}
				val.handcraft = null;
				val.handcraftProductCount = 0;
				int num = int.MaxValue;
				RecipeProto[] dataArray2 = ((ProtoSet<RecipeProto>)(object)LDB.recipes).dataArray;
				foreach (RecipeProto val2 in dataArray2)
				{
					if (!val2.Handcraft)
					{
						continue;
					}
					int num2 = Array.IndexOf(val2.Results, ((Proto)val).ID);
					if (num2 >= 0)
					{
						val.handcrafts.Add(val2);
						if (num2 < num)
						{
							val.handcraft = val2;
							val.handcraftProductCount = val2.ResultCounts[num2];
							num = num2;
						}
					}
				}
				if (handcraft != null && val.handcrafts.Contains(handcraft))
				{
					val.handcraft = handcraft;
					val.handcraftProductCount = handcraft.ResultCounts[Array.IndexOf(handcraft.Results, ((Proto)val).ID)];
				}
			}
			UIReplicatorWindow val3 = UIRoot.instance?.uiGame?.replicator;
			if ((Object)(object)val3 != (Object)null && ((ManualBehaviour)val3).active)
			{
				val3.OnTechUnlocked(0, 0, false);
				val3.OnSelectedRecipeChange(false);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(UIReplicatorWindow), "_OnOpen")]
		private static void ReplicatorOpen()
		{
			Multifunction.refreshLDB = true;
		}

		[HarmonyTranspiler]
		[HarmonyPatch(typeof(PlanetFactory), "PlanetReformAll")]
		private static IEnumerable<CodeInstruction> BulkReform(IEnumerable<CodeInstruction> instructions)
		{
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.Method(typeof(PlanetFactory), "RemoveVegeWithComponents", (Type[])null, (Type[])null);
			int num = 0;
			foreach (CodeInstruction item in list)
			{
				if (CodeInstructionExtensions.Calls(item, methodInfo))
				{
					item.opcode = OpCodes.Call;
					item.operand = AccessTools.Method(typeof(MultifunctionFixes), "RemoveVegeAndCollect", (Type[])null, (Type[])null);
					num++;
				}
			}
			Il.Require(num == 1, "PlanetReformAll RemoveVegeWithComponents");
			return list;
		}

		private static void RemoveVegeAndCollect(PlanetFactory factory, int id)
		{
			int num = ((id > 0 && id < factory.vegePool.Length && factory.vegePool[id].id == id) ? factory.vegePool[id].protoId : 0);
			Player mainPlayer = factory.gameData.mainPlayer;
			VegetableCollection val = ((mainPlayer != null) ? mainPlayer.vegetableCollection : null);
			int value = 0;
			int value2 = 0;
			val?.playerVegeDict.TryGetValue(num, out value);
			factory.RemoveVegeWithComponents(id);
			val?.playerVegeDict.TryGetValue(num, out value2);
			if (num > 0 && val != null && factory.vegePool[id].id == 0 && value == value2)
			{
				val.AddVegeToPlayer(num, 1);
			}
		}
	}
	public static class PlanetFinderFixes
	{
		public const string Target = "com.hetima.dsp.PlanetFinder";

		private const int FirstItemId = 1000;

		public static bool AlreadyFixed()
		{
			return typeof(PLFN).Assembly.GetType("PlanetFinderMod.ResourceList") != null;
		}

		private static bool IsVeinType(int id)
		{
			return id < 1000;
		}

		private static bool PlanetHasFluid(PlanetData planet, int itemId)
		{
			if (itemId >= 1000)
			{
				if (planet.waterItemId != itemId)
				{
					if (planet.gasItems != null)
					{
						return Array.IndexOf(planet.gasItems, itemId) >= 0;
					}
					return false;
				}
				return true;
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(UIPlanetFinderWindow), "IsTargetPlanet", new Type[]
		{
			typeof(PlanetListData),
			typeof(int)
		})]
		private static bool IsTargetPlanet(PlanetListData planetListData, int itemId, ref bool __result)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			PlanetData planetData = planetListData.planetData;
			__result = planetData != null && (PlanetHasFluid(planetData, itemId) || ((int)planetData.type != 5 && IsVeinType(itemId) && planetListData.IsContainItem(itemId)));
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlanetListData), "IsCalculatedOrLoaded")]
		private static bool IsCalculatedOrLoaded(PlanetListData __instance, ref bool __result)
		{
			__result = (__instance.planetData != null && __instance.planetData.scanned) || __instance.cachedVeinGroups != null;
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlanetListData), "VeinGroups")]
		private static bool VeinGroups(PlanetListData __instance, ref VeinGroup[] __result)
		{
			PlanetData planetData = __instance.planetData;
			__result = ((planetData == null || !planetData.scanned) ? __instance.cachedVeinGroups : planetData.runtimeVeinGroups);
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlanetListData), "ItemCount")]
		private static bool ItemCount(PlanetListData __instance, int itemId, ref long __result)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Invalid comparison between Unknown and I4
			long num = 0L;
			VeinGroup[] array = __instance.VeinGroups();
			if (array != null)
			{
				for (int i = 1; i < array.Length; i++)
				{
					if ((int)array[i].type == itemId)
					{
						long num2 = Math.Max(0L, array[i].amount);
						num = ((num2 > long.MaxValue - num) ? long.MaxValue : (num + num2));
					}
				}
			}
			__result = num;
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlanetListData), "ItemCountSketch")]
		private static bool ItemCountSketch(PlanetListData __instance, int itemId, ref int __result)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Invalid comparison between Unknown and I4
			long num = 0L;
			VeinGroup[] array = __instance.VeinGroups();
			if (array != null)
			{
				for (int i = 1; i < array.Length; i++)
				{
					if ((int)array[i].type == itemId)
					{
						num = Math.Min(2147483647L, num + Math.Max(0, array[i].count));
					}
				}
			}
			__result = (int)num;
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(UIPlanetFinderListItem), "OrbitalCollectorCount")]
		private static bool OrbitalCollectorCount(PlanetListData ld, ref int __result)
		{
			int num = 0;
			foreach (PlanetData item in UIPlanetFinderListItem.CollectPlanets(ld))
			{
				PlanetTransport val = item?.factory?.transport;
				StationComponent[] array = val?.stationPool;
				if (array == null)
				{
					continue;
				}
				int num2 = Math.Min(val.stationCursor, array.Length);
				for (int i = 1; i < num2; i++)
				{
					if (array[i] != null && array[i].id == i && array[i].isCollector)
					{
						num++;
					}
				}
			}
			__result = num;
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(UIPlanetFinderWindow), "SetupDistanceForSort")]
		private static bool SetupDistanceForSort(PlanetListData d, int nearStar)
		{
			PlanetData val = d.planetData;
			if (val == null && d.starData?.planets != null && d.starData.planets.Length != 0)
			{
				val = d.starData.planets[0];
			}
			int id;
			int num;
			int num2;
			if (val != null)
			{
				id = val.star.id;
				num = val.index;
				num2 = val.id;
			}
			else
			{
				if (d.starData == null)
				{
					return false;
				}
				id = d.starData.id;
				num = 0;
				num2 = d.starData.id * 100;
			}
			int num3 = ((GameMain.localPlanet != null) ? GameMain.localPlanet.id : 0);
			string distanceStr = "";
			int distanceForSort;
			if (num3 == num2)
			{
				distanceForSort = 0;
			}
			else if (num3 / 100 == num2 / 100)
			{
				distanceForSort = num + 40;
			}
			else
			{
				float num4 = StarDistance.DistanceFromHere(id, nearStar);
				distanceForSort = (int)(num4 * 10000f) + id * 100 + num;
				distanceStr = $"  ({num4:F1}ly)";
			}
			if (d.distanceForSort >= 0)
			{
				distanceForSort = d.distanceForSort;
			}
			d.distanceForSort = distanceForSort;
			d.distanceStr = distanceStr;
			return false;
		}
	}
	[BepInPlugin("bug.dsp.modspatch", "BUG_ModsPatch", "1.0.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public const string Guid = "bug.dsp.modspatch";

		internal static ManualLogSource Log;

		internal static readonly Module[] Modules = new Module[10]
		{
			new Module("UXAssist", "org.soardev.uxassist", "1.6.3", UXAssistFixes.AlreadyFixed, typeof(UXAssistFixes)),
			new Module("LaserClearing", "starfi5h.plugin.LaserClearing", "1.0.8", LaserClearingFixes.AlreadyFixed, typeof(LaserClearingFixes)),
			new Module("PlanetFinder", "com.hetima.dsp.PlanetFinder", "1.3.2", PlanetFinderFixes.AlreadyFixed, typeof(PlanetFinderFixes)),
			new Module("BuildToolOpt", "starfi5h.plugin.BuildToolOpt", "1.2.0", BuildToolOptFixes.AlreadyFixed, typeof(BuildToolOptFixes)),
			new Module("Auxilaryfunction", "cn.blacksnipe.dsp.Auxilaryfunction", "3.1.1", AuxilaryfunctionFixes.AlreadyFixed, typeof(AuxilaryfunctionFixes)),
			new Module("Multifunction", "cn.blacksnipe.dsp.Multfuntion_mod", "4.0.8", MultifunctionFixes.AlreadyFixed, typeof(MultifunctionFixes)),
			new Module("MoreMegaStructure", "Gnimaerd.DSP.plugin.MoreMegaStructure", "2.0.2", MoreMegaStructureFixes.AlreadyFixed, typeof(MoreMegaStructureFixes)),
			new Module("AllPlanetInfo", "Appun.DSP.plugin.AllPlanetInfo", "1.1.14", AllPlanetInfoFixes.AlreadyFixed, typeof(AllPlanetInfoFixes)),
			new Module("BigInventory", "Appun.DSP.plugin.BigInventory", "1.0.8", BigInventoryFixes.AlreadyFixed, typeof(BigInventoryFixes)),
			new Module("MassRecipePaste", "starfi5h.plugin.MassRecipePaste", "1.1.3", MassRecipePasteFixes.AlreadyFixed, typeof(MassRecipePasteFixes))
		};

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			Module[] modules = Modules;
			for (int i = 0; i < modules.Length; i++)
			{
				modules[i].Apply();
			}
		}
	}
	internal sealed class Module
	{
		private readonly string name;

		private readonly string guid;

		private readonly string version;

		private readonly Func<bool> alreadyFixed;

		private readonly Type patches;

		internal bool Active;

		internal Module(string name, string guid, string version, Func<bool> alreadyFixed, Type patches)
		{
			this.name = name;
			this.guid = guid;
			this.version = version;
			this.alreadyFixed = alreadyFixed;
			this.patches = patches;
		}

		internal void Apply()
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			if (!Chainloader.PluginInfos.TryGetValue(guid, out var value))
			{
				return;
			}
			string text = value.Metadata.Version.ToString();
			if (alreadyFixed())
			{
				Plugin.Log.LogInfo((object)(name + " " + text + " already contains these fixes, nothing patched"));
				return;
			}
			Harmony val = new Harmony("bug.dsp.modspatch." + name);
			try
			{
				val.PatchAll(patches);
				Active = true;
				Plugin.Log.LogInfo((object)(name + " " + text + " patched"));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)(name + " " + text + " could not be patched (fixes written for " + version + "); it is left as it is. " + ex));
				try
				{
					val.UnpatchSelf();
				}
				catch (Exception ex2)
				{
					Plugin.Log.LogError((object)(name + ": removing the partial patches failed: " + ex2.Message));
				}
			}
		}
	}
	internal static class Il
	{
		internal static void Require(bool found, string what)
		{
			if (!found)
			{
				throw new InvalidOperationException("pattern not found: " + what);
			}
		}

		internal static int Count(List<CodeInstruction> code, Func<CodeInstruction, bool> match)
		{
			int num = 0;
			foreach (CodeInstruction item in code)
			{
				if (match(item))
				{
					num++;
				}
			}
			return num;
		}
	}
	public static class UXAssistFixes
	{
		public const string Target = "org.soardev.uxassist";

		public static bool AlreadyFixed()
		{
			return AccessTools.Method(typeof(LogisticsPatch), "MissingWorkers", (Type[])null, (Type[])null) != null;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(AuxilaryfunctionWrapper), "Start")]
		private static bool AuxStart(Harmony harmony)
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			PluginInfo val = default(PluginInfo);
			if (!ModCompatHelper.TryGetLoadedPluginInfo("cn.blacksnipe.dsp.Auxilaryfunction", ref val))
			{
				return false;
			}
			Type type = default(Type);
			if (!ModCompatHelper.TryGetPluginType(val, "Auxilaryfunction.Auxilaryfunction", ref type))
			{
				UXAssist.Logger.LogWarning((object)"Failed to locate Auxilaryfunction main type");
				return false;
			}
			if (!ModCompatHelper.TryGetFieldValue<ConfigEntry<bool>>(((object)val.Instance).GetType().Assembly.GetType("Auxilaryfunction.AuxConfig") ?? type, "ShowStationInfo", (object)val.Instance, ref AuxilaryfunctionWrapper.ShowStationInfo))
			{
				UXAssist.Logger.LogWarning((object)"Failed to get ShowStationInfo from Auxilaryfunction");
			}
			Type type2 = default(Type);
			if (!ModCompatHelper.TryGetPluginType(val, "Auxilaryfunction.Patch.SpeedUpPatch", ref type2))
			{
				UXAssist.Logger.LogWarning((object)"Failed to locate Auxilaryfunction SpeedUpPatch");
				return false;
			}
			MethodInfo methodInfo = default(MethodInfo);
			if (!ModCompatHelper.TryGetPropertySetter(type2, "Enable", ref methodInfo))
			{
				UXAssist.Logger.LogWarning((object)"Failed to resolve SpeedUpPatch.set_Enable() from Auxilaryfunction");
				return false;
			}
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(AccessTools.Method(typeof(AuxilaryfunctionWrapper), "PatchSpeedUpPatchEnable", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			return false;
		}

		public static int MissingWorkers(int target, int capacity, int idle, int working)
		{
			if (idle >= 0 && working >= 0)
			{
				return (int)Math.Max(0L, (long)Math.Max(0, Math.Min(target, capacity)) - (long)idle - working);
			}
			return 0;
		}

		private static bool Local(PlanetFactory factory)
		{
			if (factory != null && GameMain.mainPlayer != null)
			{
				return GameMain.mainPlayer.factory == factory;
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(LogisticsPatch), "StationFillDrones")]
		private static bool StationFillDrones(PlanetFactory factory, StationComponent station)
		{
			if (!Local(factory) || station?.workDroneDatas == null)
			{
				return false;
			}
			int num = MissingWorkers(station.isStellar ? LogisticsPatch.AutoConfigILSDroneCount.Value : LogisticsPatch.AutoConfigPLSDroneCount.Value, station.workDroneDatas.Length, station.idleDroneCount, station.workDroneCount);
			if (num > 0)
			{
				int num2 = default(int);
				station.idleDroneCount += GameMain.data.mainPlayer.package.TakeItem(5001, num, ref num2);
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(LogisticsPatch), "StationFillShips")]
		private static bool StationFillShips(PlanetFactory factory, StationComponent station)
		{
			if (!Local(factory) || station?.workShipDatas == null)
			{
				return false;
			}
			int num = MissingWorkers(LogisticsPatch.AutoConfigILSShipCount.Value, Math.Min(64, station.workShipDatas.Length), station.idleShipCount, station.workShipCount);
			if (num > 0)
			{
				int num2 = default(int);
				station.idleShipCount += GameMain.data.mainPlayer.package.TakeItem(5002, num, ref num2);
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(LogisticsPatch), "DispenserFillCouriers")]
		private static bool DispenserFillCouriers(PlanetFactory factory, DispenserComponent dispenser)
		{
			if (!Local(factory) || dispenser?.workCourierDatas == null)
			{
				return false;
			}
			int num = MissingWorkers(LogisticsPatch.AutoConfigDispenserCourierCount.Value, dispenser.workCourierDatas.Length, dispenser.idleCourierCount, dispenser.workCourierCount);
			if (num > 0)
			{
				int num2 = default(int);
				dispenser.idleCourierCount += GameMain.data.mainPlayer.package.TakeItem(5003, num, ref num2);
			}
			return false;
		}
	}
}
namespace ModsPatch.BigInventory
{
	public static class ScreenLimits
	{
		public const int NativeMinColumns = 10;

		public const int NativeMaxColumns = 30;

		public const int HardMaxRows = 100;

		public const int MaxCells = 400;

		public const int EdgePixels = 8;

		public static bool Active;

		public static float OverrideUnitsWidth;

		public static float OverrideUnitsHeight;

		public static bool Available(out float unitsWidth, out float unitsHeight)
		{
			unitsWidth = OverrideUnitsWidth;
			unitsHeight = OverrideUnitsHeight;
			if (unitsWidth > 0f && unitsHeight > 0f)
			{
				return true;
			}
			return ReadScreen(out unitsWidth, out unitsHeight);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static bool ReadScreen(out float unitsWidth, out float unitsHeight)
		{
			//IL_0023: 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)
			unitsWidth = (unitsHeight = 0f);
			int height = Screen.height;
			if (height < 64)
			{
				return false;
			}
			float num = (float)UICanvasScalerHandler.uiLayoutHeight / (float)height;
			Rect safeArea = Screen.safeArea;
			unitsWidth = (((Rect)(ref safeArea)).width - 16f) * num;
			unitsHeight = (((Rect)(ref safeArea)).height - 16f) * num;
			if (unitsWidth > 0f)
			{
				return unitsHeight > 0f;
			}
			return false;
		}

		private static int Clamp(int value, int min, int max)
		{
			return Math.Max(min, Math.Min(max, value));
		}

		private static int Fit(float units, float fixedUnits)
		{
			return (int)Math.Floor((units - fixedUnits) / 50f);
		}

		public static int MaxColumns(float unitsWidth, int deliveryColumns)
		{
			return Clamp(Fit(unitsWidth, 88 + ((deliveryColumns > 0) ? (deliveryColumns * 50 + 6) : 0)), 10, 30);
		}

		public static int MaxRows(float unitsHeight, int columns, int deliveryColumns)
		{
			return Clamp(Math.Min(Fit(unitsHeight, 126 + ((deliveryColumns > 0) ? 26 : 0)), 400 / Math.Max(1, columns)), 1, 100);
		}

		public static int MaxColumns(int deliveryColumns)
		{
			if (!Available(out var unitsWidth, out var _))
			{
				return 30;
			}
			return MaxColumns(unitsWidth, deliveryColumns);
		}

		public static int MaxRows(int columns, int deliveryColumns)
		{
			if (!Available(out var _, out var unitsHeight))
			{
				return Clamp(400 / Math.Max(1, columns), 1, 100);
			}
			return MaxRows(unitsHeight, columns, deliveryColumns);
		}

		public static int MaxColumnsNow()
		{
			return MaxColumns(DeliveryColumnsNow());
		}

		public static int MaxRowsNow(int columns)
		{
			return MaxRows(columns, DeliveryColumnsNow());
		}

		private static int DeliveryColumnsNow()
		{
			Player mainPlayer = GameMain.mainPlayer;
			DeliveryPackage val = ((mainPlayer != null) ? mainPlayer.deliveryPackage : null);
			if (val != null)
			{
				return Clamp(val.colCount, 0, 5);
			}
			return 0;
		}

		public static string Describe(int deliveryColumns, int columns)
		{
			if (!Available(out var unitsWidth, out var unitsHeight))
			{
				return "screen size unknown: native limits (columns 10-30, 400 slots)";
			}
			return Limits(unitsWidth, unitsHeight, deliveryColumns, columns) + ((OverrideUnitsWidth > 0f) ? "" : Resolution());
		}

		private static string Limits(float w, float h, int deliveryColumns, int columns)
		{
			return $"columns 10-{MaxColumns(w, deliveryColumns)}, rows 1-{MaxRows(h, columns, deliveryColumns)} at {columns} columns (400 slots max)";
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static string Resolution()
		{
			return $" on {Screen.width}x{Screen.height} px, UI layout {UICanvasScalerHandler.uiLayoutHeight}";
		}
	}
}