using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using NebulaAPI;
using NebulaAPI.GameState;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("starfi5h.plugin.DeliverySlotsTweaks")]
[assembly: AssemblyProduct("DeliverySlotsTweaks")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.5.8.0")]
[module: UnverifiableCode]
namespace DeliverySlotsTweaks;
public class Compatibility
{
public static class BlueprintTweaks_Patch
{
public const string GUID = "org.kremnev8.plugin.BlueprintTweaks";
public static void Init(Harmony harmony)
{
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Expected O, but got Unknown
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Expected O, but got Unknown
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
//IL_00c5: Expected O, but got Unknown
try
{
if (Chainloader.PluginInfos.TryGetValue("org.kremnev8.plugin.BlueprintTweaks", out var value))
{
Type type = ((object)value.Instance).GetType().Assembly.GetType("BlueprintTweaks.BlueprintPasteExtension");
harmony.Patch((MethodBase)AccessTools.Method(type, "OnUpdate", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(DeliveryPackagePatch).GetMethod("UIBuildMenu_Transpiler")), (HarmonyMethod)null, (HarmonyMethod)null);
harmony.Patch((MethodBase)AccessTools.Method(type, "CheckItems", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(DeliveryPackagePatch).GetMethod("UIBuildMenu_Transpiler")), (HarmonyMethod)null, (HarmonyMethod)null);
harmony.Patch((MethodBase)AccessTools.Method(type, "CheckItems", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(DeliveryPackagePatch).GetMethod("TakeItem_Transpiler")), (HarmonyMethod)null, (HarmonyMethod)null);
}
}
catch (Exception ex)
{
Plugin.Log.LogWarning((object)"Auxilaryfunction compatibility failed! Last working version: 1.6.4");
Plugin.Log.LogWarning((object)ex);
}
}
}
public static class Auxilaryfunction_Patch
{
public const string GUID = "cn.blacksnipe.dsp.Auxilaryfunction";
public static void Init(Harmony harmony)
{
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Expected O, but got Unknown
try
{
if (Chainloader.PluginInfos.TryGetValue("cn.blacksnipe.dsp.Auxilaryfunction", out var value))
{
Type type = ((object)value.Instance).GetType().Assembly.GetType("Auxilaryfunction.Auxilaryfunction");
harmony.Patch((MethodBase)AccessTools.Method(type, "AutoMovetounbuilt", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(DeliveryPackagePatch).GetMethod("UIBuildMenu_Transpiler")), (HarmonyMethod)null, (HarmonyMethod)null);
}
}
catch (Exception ex)
{
Plugin.Log.LogWarning((object)"Auxilaryfunction compatibility failed! Last working version: 2.8.2");
Plugin.Log.LogWarning((object)ex);
}
}
}
public static class Multfunction_mod_Patch
{
public const string GUID = "cn.blacksnipe.dsp.Multfuntion_mod";
private static ConfigEntry<bool> architectMode;
public static void Init(Harmony harmony)
{
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Expected O, but got Unknown
try
{
if (Chainloader.PluginInfos.TryGetValue("cn.blacksnipe.dsp.Multfuntion_mod", out var value))
{
Type type = ((object)value.Instance).GetType().Assembly.GetType("Multifunction_mod.GUIDraw");
harmony.Patch((MethodBase)AccessTools.Method(type, "BuildPannel", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Multfunction_mod_Patch).GetMethod("BuildPannel_Postfix")), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
architectMode = (ConfigEntry<bool>)AccessTools.Field(AccessTools.TypeByName("Multifunction_mod.Multifunction"), "ArchitectMode").GetValue(null);
DeliveryPackagePatch.architectMode = architectMode.Value;
Plugin.Log.LogDebug((object)("Multfunction_mod ArchitectModeEnabled: " + DeliveryPackagePatch.architectMode));
}
}
catch (Exception ex)
{
Plugin.Log.LogWarning((object)"Multfunction_mod compatibility failed! Last working version: 3.4.5");
Plugin.Log.LogWarning((object)ex);
}
}
public static void BuildPannel_Postfix()
{
DeliveryPackagePatch.architectMode = architectMode.Value;
}
}
public static class Nebula_Patch
{
public const string GUID = "dsp.nebula-multiplayer";
private static bool IsPatched;
public static bool IsActive { get; private set; }
public static void Init(Harmony harmony)
{
try
{
if (Chainloader.PluginInfos.TryGetValue("dsp.nebula-multiplayer", out var _))
{
Patch(harmony);
}
}
catch (Exception ex)
{
Plugin.Log.LogWarning((object)"Nebula compatibility failed!");
Plugin.Log.LogWarning((object)ex);
}
}
public static bool IsOthers()
{
IFactoryManager factories = NebulaModAPI.MultiplayerSession.Factories;
if (factories.IsIncomingRequest.Value)
{
return factories.PacketAuthor != NebulaModAPI.MultiplayerSession.LocalPlayer.Id;
}
return false;
}
private static void Patch(Harmony harmony)
{
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Expected O, but got Unknown
if (NebulaModAPI.NebulaIsInstalled && !IsPatched)
{
NebulaModAPI.OnMultiplayerGameStarted = (Action)Delegate.Combine(NebulaModAPI.OnMultiplayerGameStarted, new Action(OnMultiplayerGameStarted));
NebulaModAPI.OnMultiplayerGameEnded = (Action)Delegate.Combine(NebulaModAPI.OnMultiplayerGameEnded, new Action(OnMultiplayerGameEnded));
Type type = AccessTools.TypeByName("NebulaWorld.SimulatedWorld");
harmony.Patch((MethodBase)AccessTools.Method(type, "SetupInitialPlayerState", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(Plugin), "ApplyConfigs", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
IsPatched = true;
}
}
private static void OnMultiplayerGameStarted()
{
IsActive = NebulaModAPI.IsMultiplayerActive;
}
private static void OnMultiplayerGameEnded()
{
IsActive = false;
}
}
public static class RebindBuildBar_Patch
{
public const string GUID = "org.kremnev8.plugin.RebindBuildBar";
public static void Init(Harmony harmony)
{
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Expected O, but got Unknown
try
{
if (Chainloader.PluginInfos.TryGetValue("org.kremnev8.plugin.RebindBuildBar", out var value))
{
Type type = ((object)value.Instance).GetType().Assembly.GetType("RebindBuildBar.Patches");
harmony.Patch((MethodBase)AccessTools.Method(type, "EnableButton", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(DeliveryPackagePatch).GetMethod("UIBuildMenu_Transpiler")), (HarmonyMethod)null, (HarmonyMethod)null);
}
}
catch (Exception ex)
{
Plugin.Log.LogWarning((object)"RebindBuildBar compatibility failed! Last working version: 1.0.4");
Plugin.Log.LogWarning((object)ex);
}
}
}
public static class UnlimitedFoundations_Patch
{
public const string GUID1 = "com.aekoch.mods.dsp.UnlimitedFoundations";
public const string GUID2 = "com.tinysquid.infinitefoundations";
public static void Init(Harmony harmony)
{
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Expected O, but got Unknown
try
{
if (Chainloader.PluginInfos.ContainsKey("com.aekoch.mods.dsp.UnlimitedFoundations") || Chainloader.PluginInfos.ContainsKey("com.tinysquid.infinitefoundations"))
{
harmony.Patch((MethodBase)AccessTools.Method(typeof(DeliveryPackagePatch), "GetItemCount", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(UnlimitedFoundations_Patch).GetMethod("GetItemCount_Postfix")), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
}
}
catch (Exception ex)
{
Plugin.Log.LogWarning((object)"UnlimitedFoundations compatibility failed!");
Plugin.Log.LogWarning((object)ex);
}
}
public static void GetItemCount_Postfix(int itemId, ref int __result)
{
if (itemId == 1131)
{
__result = 9999;
}
}
}
public static void Init(Harmony harmony)
{
BlueprintTweaks_Patch.Init(harmony);
Multfunction_mod_Patch.Init(harmony);
RebindBuildBar_Patch.Init(harmony);
UnlimitedFoundations_Patch.Init(harmony);
Nebula_Patch.Init(harmony);
}
}
public class DeliveryPackagePatch
{
public static bool architectMode = false;
public static int maxDeliveryGridIndex = 0;
private static readonly Dictionary<int, int> packageItemCount = new Dictionary<int, int>();
private static readonly Dictionary<int, int> deliveryItemCount = new Dictionary<int, int>();
private static readonly Dictionary<int, int> deliveryGridindex = new Dictionary<int, int>();
public static void Count(StorageComponent package)
{
packageItemCount.Clear();
GRID[] grids = package.grids;
int num = ((package.size < grids.Length) ? package.size : grids.Length);
for (int i = 0; i < num; i++)
{
int itemId = grids[i].itemId;
if (itemId > 0)
{
if (packageItemCount.ContainsKey(itemId))
{
packageItemCount[itemId] += grids[i].count;
}
else
{
packageItemCount.Add(itemId, grids[i].count);
}
}
}
}
public static void Count(DeliveryPackage package)
{
deliveryItemCount.Clear();
deliveryGridindex.Clear();
GRID[] grids = package.grids;
for (int i = 0; i <= maxDeliveryGridIndex; i++)
{
int itemId = grids[i].itemId;
if (itemId > 0)
{
deliveryItemCount.Add(itemId, grids[i].count);
deliveryGridindex.Add(itemId, i);
}
}
}
public static int GetItemCount(StorageComponent _, int itemId)
{
if (architectMode)
{
return 999;
}
packageItemCount.TryGetValue(itemId, out var value);
deliveryItemCount.TryGetValue(itemId, out var value2);
return value + value2;
}
public static int GetItemCountDummy(StorageComponent _, int itemId)
{
return 999;
}
public static int TakeItem(StorageComponent storage, int itemId, int count, out int inc)
{
if (deliveryGridindex.TryGetValue(itemId, out var value))
{
GameMain.mainPlayer.packageUtility.TakeItemFromAllPackages(value, ref itemId, ref count, ref inc, false);
return count;
}
return storage.TakeItem(itemId, count, ref inc);
}
public static void TakeTailItems(StorageComponent storage, ref int itemId, ref int count, out int inc, bool _)
{
if (architectMode)
{
inc = 0;
return;
}
if (Compatibility.Nebula_Patch.IsActive && Compatibility.Nebula_Patch.IsOthers())
{
inc = 0;
return;
}
if (deliveryGridindex.TryGetValue(itemId, out var value))
{
GameMain.mainPlayer.packageUtility.TakeItemFromAllPackages(value, ref itemId, ref count, ref inc, false);
if (packageItemCount.ContainsKey(itemId))
{
int num = packageItemCount[itemId] - count;
packageItemCount[itemId] = num;
if (num == 0)
{
packageItemCount.Remove(itemId);
}
}
else if (deliveryItemCount.ContainsKey(itemId))
{
int num2 = deliveryItemCount[itemId] - count;
deliveryItemCount[itemId] = num2;
if (num2 == 0)
{
deliveryItemCount.Remove(itemId);
}
}
return;
}
storage.TakeTailItems(ref itemId, ref count, ref inc, false);
if (packageItemCount.ContainsKey(itemId))
{
int num3 = packageItemCount[itemId] - count;
packageItemCount[itemId] = num3;
if (num3 == 0)
{
packageItemCount.Remove(itemId);
}
}
}
[HarmonyPrefix]
[HarmonyPatch(typeof(Mecha), "GameTick")]
public static void Prepare(Mecha __instance, long time)
{
if (__instance?.player != null && __instance.player == GameMain.mainPlayer)
{
Count(__instance.player.package);
Count(__instance.player.deliveryPackage);
if (time % 30 == 0L && Plugin.AutoRefillWarper.Value)
{
TryReillWarper(__instance);
}
}
}
private static void TryReillWarper(Mecha mecha)
{
if (!mecha.HasWarper())
{
int itemId = 1210;
int count = 1;
if (GetItemCount(null, itemId) > 0)
{
TakeTailItems(mecha.player.package, ref itemId, ref count, out var inc, _: false);
int num = default(int);
mecha.warpStorage.AddItem(itemId, count, inc, ref num, false);
}
}
}
[HarmonyPrefix]
[HarmonyPatch(typeof(StorageComponent), "Sort")]
public static void Sort_Prefix(StorageComponent __instance)
{
if (!Plugin.SortToDelieverySlots.Value)
{
return;
}
Player mainPlayer = GameMain.mainPlayer;
if (__instance != ((mainPlayer != null) ? mainPlayer.package : null))
{
return;
}
GRID[] grids = __instance.grids;
DeliveryPackage deliveryPackage = GameMain.mainPlayer.deliveryPackage;
int inc = default(int);
for (int num = ((__instance.size < __instance.grids.Length) ? __instance.size : __instance.grids.Length) - 1; num > 0; num--)
{
ref GRID reference = ref grids[num];
int itemId = reference.itemId;
if (itemId > 0 && deliveryGridindex.ContainsKey(itemId))
{
int num2 = deliveryPackage.AddItem(deliveryGridindex[itemId], itemId, reference.count, reference.inc, ref inc);
reference.count -= num2;
reference.inc = inc;
}
}
}
[HarmonyTranspiler]
[HarmonyPatch(typeof(ConstructionModuleComponent), "PlaceItems")]
public static IEnumerable<CodeInstruction> PlaceItems_Transpiler(IEnumerable<CodeInstruction> instructions)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Expected O, but got Unknown
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Expected O, but got Unknown
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Expected O, but got Unknown
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Expected O, but got Unknown
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Expected O, but got Unknown
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Expected O, but got Unknown
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Expected O, but got Unknown
//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
//IL_00ae: Expected O, but got Unknown
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
//IL_00c1: Expected O, but got Unknown
//IL_00de: Unknown result type (might be due to invalid IL or missing references)
//IL_00e4: Expected O, but got Unknown
//IL_0100: Unknown result type (might be due to invalid IL or missing references)
//IL_0106: Expected O, but got Unknown
//IL_0127: Unknown result type (might be due to invalid IL or missing references)
//IL_012d: Expected O, but got Unknown
//IL_013b: Unknown result type (might be due to invalid IL or missing references)
//IL_0141: Expected O, but got Unknown
//IL_014f: Unknown result type (might be due to invalid IL or missing references)
//IL_0155: Expected O, but got Unknown
//IL_0163: Unknown result type (might be due to invalid IL or missing references)
//IL_0169: Expected O, but got Unknown
//IL_0177: Unknown result type (might be due to invalid IL or missing references)
//IL_017d: Expected O, but got Unknown
//IL_019f: Unknown result type (might be due to invalid IL or missing references)
//IL_01a5: Expected O, but got Unknown
try
{
CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[5]
{
new CodeMatch((OpCode?)OpCodes.Br, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(ConstructionModuleComponent), "entityId"), (string)null),
new CodeMatch((OpCode?)OpCodes.Ldc_I4_0, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ble, (object)null, (string)null)
}).Insert((CodeInstruction[])(object)new CodeInstruction[4]
{
new CodeInstruction(OpCodes.Ldarg_0, (object)null),
new CodeInstruction(OpCodes.Ldarg_2, (object)null),
new CodeInstruction(OpCodes.Ldloca_S, (object)(byte)0),
new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(DeliveryPackagePatch), "AddConstructableCountsInStorage", (Type[])null, (Type[])null))
});
val.MatchForward(true, (CodeMatch[])(object)new CodeMatch[7]
{
new CodeMatch((OpCode?)OpCodes.Ldarg_2, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.DeclaredPropertyGetter(typeof(Player), "package"), (string)null),
new CodeMatch((OpCode?)OpCodes.Ldloca_S, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldloca_S, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldloca_S, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldc_I4_0, (object)null, (string)null),
new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => i.opcode == OpCodes.Callvirt && ((MethodInfo)i.operand).Name == "TakeTailItems"), (string)null)
}).Repeat((Action<CodeMatcher>)delegate(CodeMatcher matcher)
{
matcher.SetAndAdvance(OpCodes.Call, (object)AccessTools.Method(typeof(DeliveryPackagePatch), "TakeTailItems", (Type[])null, (Type[])null));
}, (Action<string>)null);
return val.InstructionEnumeration();
}
catch (Exception ex)
{
Plugin.Log.LogWarning((object)"Transpiler PlaceItems error");
Plugin.Log.LogWarning((object)ex);
return instructions;
}
}
private static void AddConstructableCountsInStorage(ConstructionModuleComponent constructionModule, Player player, ref int num)
{
if (((player != null) ? player.deliveryPackage : null) == null)
{
return;
}
ConstructableCount[] constructableCountsInStorage = constructionModule.constructableCountsInStorage;
GRID[] grids = player.deliveryPackage.grids;
for (int i = 0; i <= maxDeliveryGridIndex; i++)
{
int itemId = grids[i].itemId;
if (itemId > 0 && ItemProto.constructableIdHash.Contains(itemId))
{
int count = grids[i].count;
int num2 = ItemProto.constructableIndiceById[itemId];
constructableCountsInStorage[num2].haveCount += count;
num += count;
}
}
}
[HarmonyTranspiler]
[HarmonyPatch(typeof(MechaForge), "TryAddTask")]
[HarmonyPatch(typeof(MechaForge), "TryTaskWithTestPackage")]
public static IEnumerable<CodeInstruction> TryAddTask_Transpiler(IEnumerable<CodeInstruction> instructions)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
try
{
return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
{
new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => i.opcode == OpCodes.Call && ((MethodInfo)i.operand).Name == "TryAddTaskIterate"), (string)null)
}).SetAndAdvance(OpCodes.Call, (object)AccessTools.Method(typeof(DeliveryPackagePatch), "TryAddTaskIterate", (Type[])null, (Type[])null)).InstructionEnumeration();
}
catch (Exception ex)
{
Plugin.Log.LogWarning((object)"Transpiler TryAddTask error");
Plugin.Log.LogWarning((object)ex);
return instructions;
}
}
public static bool TryAddTaskIterate(MechaForge mechaForge, RecipeProto recipe, int count)
{
Count(mechaForge.player.deliveryPackage);
foreach (KeyValuePair<int, int> item in deliveryItemCount)
{
mechaForge._test_pack.Alter(item.Key, item.Value);
}
return mechaForge.TryAddTaskIterate(recipe, count);
}
[HarmonyTranspiler]
[HarmonyPatch(typeof(MechaForge), "AddTaskIterate")]
[HarmonyPatch(typeof(Mecha), "AutoReplenishAmmo")]
public static IEnumerable<CodeInstruction> TakeItem_Transpiler(IEnumerable<CodeInstruction> instructions)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
try
{
return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
{
new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => i.opcode == OpCodes.Callvirt && ((MethodInfo)i.operand).Name == "TakeItem"), (string)null)
}).Repeat((Action<CodeMatcher>)delegate(CodeMatcher matcher)
{
matcher.SetAndAdvance(OpCodes.Call, (object)AccessTools.Method(typeof(DeliveryPackagePatch), "TakeItem", (Type[])null, (Type[])null));
}, (Action<string>)null).InstructionEnumeration();
}
catch (Exception ex)
{
Plugin.Log.LogWarning((object)"Transpiler StorageComponent.TakeItem error");
Plugin.Log.LogWarning((object)ex);
return instructions;
}
}
[HarmonyTranspiler]
[HarmonyPatch(typeof(BuildTool_Reform), "ReformAction")]
[HarmonyPatch(typeof(BuildTool_Reform), "RemoveBasePit")]
[HarmonyPatch(typeof(PlanetFactory), "EntityAutoReplenishIfNeeded")]
[HarmonyPatch(typeof(PlanetFactory), "StationAutoReplenishIfNeeded")]
[HarmonyPatch(typeof(PlayerAction_Inspect), "GameTick")]
[HarmonyPatch(typeof(UIBlueprintInspector), "OnPlayerPackageChange")]
[HarmonyPatch(typeof(UIBlueprintInspector), "SetComponentItem")]
[HarmonyPatch(typeof(UIBuildMenu), "_OnUpdate")]
[HarmonyPatch(typeof(UIBuildMenu), "OnChildButtonClick")]
[HarmonyPatch(typeof(UIHandTip), "_OnUpdate")]
[HarmonyPatch(typeof(UIRemoveBasePitButton), "_OnUpdate")]
[HarmonyPatch(typeof(UITurretWindow), "OnHandFillAmmoButtonClick")]
public static IEnumerable<CodeInstruction> UIBuildMenu_Transpiler(IEnumerable<CodeInstruction> instructions)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
try
{
return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
{
new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => i.opcode == OpCodes.Callvirt && ((MethodInfo)i.operand).Name == "GetItemCount"), (string)null)
}).Repeat((Action<CodeMatcher>)delegate(CodeMatcher matcher)
{
matcher.SetAndAdvance(OpCodes.Call, (object)AccessTools.Method(typeof(DeliveryPackagePatch), "GetItemCount", (Type[])null, (Type[])null));
}, (Action<string>)null).InstructionEnumeration();
}
catch (Exception ex)
{
Plugin.Log.LogWarning((object)"Transpiler UIBuildMenu._OnUpdate error");
Plugin.Log.LogWarning((object)ex);
return instructions;
}
}
[HarmonyTranspiler]
[HarmonyAfter(new string[] { "dsp.nebula-multiplayer" })]
[HarmonyPatch(typeof(BuildTool_Click), "CreatePrebuilds")]
[HarmonyPatch(typeof(BuildTool_Path), "CreatePrebuilds")]
[HarmonyPatch(typeof(BuildTool_Addon), "CreatePrebuilds")]
[HarmonyPatch(typeof(BuildTool_Inserter), "CreatePrebuilds")]
[HarmonyPatch(typeof(BuildTool_BlueprintPaste), "CreatePrebuilds")]
[HarmonyPatch(typeof(BuildTool_Reform), "ReformAction")]
[HarmonyPatch(typeof(BuildTool_Reform), "RemoveBasePit")]
[HarmonyPatch(typeof(PlanetFactory), "EntityAutoReplenishIfNeeded")]
[HarmonyPatch(typeof(PlanetFactory), "StationAutoReplenishIfNeeded")]
[HarmonyPatch(typeof(Player), "TakeItemFromPlayer")]
[HarmonyPatch(typeof(PlayerAction_Build), "DoUpgradeObject")]
[HarmonyPatch(typeof(PlayerAction_Inspect), "GameTick")]
[HarmonyPatch(typeof(UITurretWindow), "OnHandFillAmmoButtonClick")]
public static IEnumerable<CodeInstruction> CheckBuildConditions_Transpiler(IEnumerable<CodeInstruction> instructions, MethodBase __originalMethod)
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Expected O, but got Unknown
try
{
int num = 1;
if (__originalMethod.Name == "StationAutoReplenishIfNeeded")
{
num = 2;
}
else if (__originalMethod.Name == "EntityAutoReplenishIfNeeded")
{
num = 3;
}
CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).End();
for (int j = 0; j < num; j++)
{
val.MatchBack(false, (CodeMatch[])(object)new CodeMatch[1]
{
new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => i.opcode == OpCodes.Callvirt && ((MethodInfo)i.operand).Name == "TakeTailItems"), (string)null)
}).SetAndAdvance(OpCodes.Call, (object)AccessTools.Method(typeof(DeliveryPackagePatch), "TakeTailItems", (Type[])null, (Type[])null));
}
return val.InstructionEnumeration();
}
catch (Exception ex)
{
Plugin.Log.LogWarning((object)"Transpiler CreatePrebuilds error");
Plugin.Log.LogWarning((object)ex);
return instructions;
}
}
[HarmonyTranspiler]
[HarmonyPatch(typeof(PlayerAction_Build), "GameTick")]
public static IEnumerable<CodeInstruction> PlayerAction_Build_Transpiler(IEnumerable<CodeInstruction> instructions)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
try
{
return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
{
new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => i.opcode == OpCodes.Callvirt && ((MethodInfo)i.operand).Name == "_GameTick"), (string)null)
}).SetAndAdvance(OpCodes.Call, (object)AccessTools.Method(typeof(DeliveryPackagePatch), "BuildTool_GameTick", (Type[])null, (Type[])null)).InstructionEnumeration();
}
catch (Exception ex)
{
Plugin.Log.LogWarning((object)"Transpiler PlayerAction_Build.GameTick error");
Plugin.Log.LogWarning((object)ex);
return instructions;
}
}
public static void BuildTool_GameTick(BuildTool @this, long time)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Expected O, but got Unknown
if (@this.active)
{
@this.mouseRay = @this.mainCamera.ScreenPointToRay(Input.mousePosition);
@this.SetFactoryReferences();
int num = @this.player.package.size + maxDeliveryGridIndex + 1;
if (@this.tmpPackage == null)
{
@this.tmpPackage = new StorageComponent(num);
}
if (@this.tmpPackage.size != num)
{
@this.tmpPackage.SetSize(num);
}
Array.Copy(@this.player.package.grids, @this.tmpPackage.grids, @this.player.package.size);
GRID[] grids = @this.player.deliveryPackage.grids;
for (int i = @this.player.package.size; i < num; i++)
{
ref GRID reference = ref grids[i - @this.player.package.size];
@this.tmpPackage.grids[i].itemId = reference.itemId;
@this.tmpPackage.grids[i].count = reference.count;
}
@this.tmpInhandId = @this.player.inhandItemId;
@this.tmpInhandCount = @this.player.inhandItemCount;
try
{
@this._OnTick(time);
}
catch (Exception ex)
{
Debug.LogError((object)ex);
}
@this.frame++;
}
}
}
public class PlayerPackagePatch
{
private static int packageStacksize = 1000;
private static int packageStackMultiplier = 1;
public static void OnConfigChange()
{
packageStackMultiplier = 1;
if (Plugin.PlayerPackageStackSize.Value > 0)
{
packageStacksize = Plugin.PlayerPackageStackSize.Value;
Plugin.Log.LogDebug((object)("PlayerPackage stack count:" + packageStacksize));
if (GameMain.mainPlayer == null)
{
return;
}
GRID[] grids = GameMain.mainPlayer.package.grids;
for (int i = 0; i < GameMain.mainPlayer.package.size; i++)
{
if (grids[i].filter > 0)
{
grids[i].stackSize = packageStacksize;
}
}
}
else
{
if (Plugin.PlayerPackageStackMultiplier.Value <= 0)
{
return;
}
packageStackMultiplier = Plugin.PlayerPackageStackMultiplier.Value;
Plugin.Log.LogDebug((object)("PlayerPackage stack multiplier:" + packageStackMultiplier));
if (GameMain.mainPlayer == null)
{
return;
}
GRID[] grids2 = GameMain.mainPlayer.package.grids;
for (int j = 0; j < GameMain.mainPlayer.package.size; j++)
{
int filter = grids2[j].filter;
if (filter > 0 && filter < StorageComponent.itemStackCount.Length)
{
grids2[j].stackSize = StorageComponent.itemStackCount[filter] * packageStackMultiplier;
}
}
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(StorageComponent), "SetFilter")]
public static void OverwritePlayerPackageStacksize2(StorageComponent __instance, int gridIndex, int filterId)
{
if (filterId > 0 && IsPlayerStorage(__instance))
{
if (Plugin.PlayerPackageStackSize.Value > 0)
{
__instance.grids[gridIndex].stackSize = packageStacksize;
}
else
{
__instance.grids[gridIndex].stackSize = StorageComponent.itemStackCount[filterId] * packageStackMultiplier;
}
}
}
[HarmonyTranspiler]
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
[HarmonyPatch(typeof(StorageComponent), "AddItemStacked")]
[HarmonyPatch(typeof(StorageComponent), "Sort")]
[HarmonyPatch(typeof(StorageComponent), "AddItemForSort")]
private static IEnumerable<CodeInstruction> OverwritePlayerPackageStacksize(IEnumerable<CodeInstruction> instructions, ILGenerator il)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Expected O, but got Unknown
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Expected O, but got Unknown
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Expected O, but got Unknown
//IL_0160: Unknown result type (might be due to invalid IL or missing references)
//IL_0166: Expected O, but got Unknown
//IL_0183: Unknown result type (might be due to invalid IL or missing references)
//IL_0189: Expected O, but got Unknown
//IL_0196: Unknown result type (might be due to invalid IL or missing references)
//IL_019c: Expected O, but got Unknown
//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
//IL_01bd: Expected O, but got Unknown
//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
//IL_01cb: Expected O, but got Unknown
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
//IL_00ce: Expected O, but got Unknown
//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
//IL_00f1: Expected O, but got Unknown
//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
//IL_0104: Expected O, but got Unknown
//IL_010c: Unknown result type (might be due to invalid IL or missing references)
//IL_0112: Expected O, but got Unknown
//IL_012d: Unknown result type (might be due to invalid IL or missing references)
//IL_0133: Expected O, but got Unknown
//IL_0140: Unknown result type (might be due to invalid IL or missing references)
//IL_0146: Expected O, but got Unknown
CodeMatcher val = new CodeMatcher(instructions, il);
Label label = default(Label);
val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
{
new CodeMatch((OpCode?)OpCodes.Ldsfld, (object)AccessTools.Field(typeof(StorageComponent), "itemStackCount"), (string)null)
}).Advance(1).CreateLabelAt(val.Pos, ref label);
int pos = val.Pos;
Label label2 = default(Label);
val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
{
new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => CodeInstructionExtensions.IsStloc(i, (LocalBuilder)null)), (string)null)
}).CreateLabelAt(val.Pos, ref label2);
if (Plugin.PlayerPackageStackSize.Value > 0)
{
val.Advance(pos - val.Pos);
val.Insert((CodeInstruction[])(object)new CodeInstruction[6]
{
new CodeInstruction(OpCodes.Ldarg_0, (object)null),
new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(PlayerPackagePatch), "IsPlayerStorage", (Type[])null, (Type[])null)),
new CodeInstruction(OpCodes.Brfalse_S, (object)label),
new CodeInstruction(OpCodes.Pop, (object)null),
new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(PlayerPackagePatch), "packageStacksize")),
new CodeInstruction(OpCodes.Br_S, (object)label2)
});
}
else
{
val.Insert((CodeInstruction[])(object)new CodeInstruction[5]
{
new CodeInstruction(OpCodes.Ldarg_0, (object)null),
new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(PlayerPackagePatch), "IsPlayerStorage", (Type[])null, (Type[])null)),
new CodeInstruction(OpCodes.Brfalse_S, (object)label2),
new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(PlayerPackagePatch), "packageStackMultiplier")),
new CodeInstruction(OpCodes.Mul, (object)null)
});
}
return val.Instructions();
}
public static bool IsPlayerStorage(StorageComponent storageComponent)
{
if (storageComponent != GameMain.mainPlayer.package)
{
return storageComponent == GameMain.mainPlayer.mecha.reactorStorage;
}
return true;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(PackageStatistics), "Count")]
private static bool CountOverwrite(PackageStatistics __instance, StorageComponent package)
{
if (!IsPlayerStorage(package))
{
return true;
}
__instance.itemBundle.Clear();
ref GRID[] grids = ref package.grids;
int num = 0;
if (packageStackMultiplier > 1)
{
int[] itemStackCount = StorageComponent.itemStackCount;
for (int i = 0; i < package.size; i++)
{
int itemId = grids[i].itemId;
if (itemId > 0)
{
__instance.itemBundle.Add(itemId, grids[i].count, itemStackCount[itemId] * packageStackMultiplier - grids[i].count);
}
else
{
num++;
}
}
if (num > 0)
{
int[] itemIds = ItemProto.itemIds;
int num2 = itemIds.Length;
for (int j = 0; j < num2; j++)
{
__instance.itemBundle.Add(itemIds[j], 0, itemStackCount[itemIds[j]] * packageStackMultiplier * num);
}
}
}
else
{
for (int k = 0; k < package.size; k++)
{
int itemId2 = grids[k].itemId;
if (itemId2 > 0)
{
__instance.itemBundle.Add(itemId2, grids[k].count, packageStacksize - grids[k].count);
}
else
{
num++;
}
}
if (num > 0)
{
int[] itemIds2 = ItemProto.itemIds;
for (int l = 0; l < itemIds2.Length; l++)
{
__instance.itemBundle.Add(itemIds2[l], 0, packageStacksize * num);
}
}
}
return false;
}
}
[BepInPlugin("starfi5h.plugin.DeliverySlotsTweaks", "DeliverySlotsTweaks", "1.5.8")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class Plugin : BaseUnityPlugin
{
public const string GUID = "starfi5h.plugin.DeliverySlotsTweaks";
public const string NAME = "DeliverySlotsTweaks";
public const string VERSION = "1.5.8";
public static Plugin Instance;
public static ManualLogSource Log;
public static ConfigEntry<bool> UseLogisticSlots;
public static ConfigEntry<bool> AutoRefillFuel;
public static ConfigEntry<bool> AutoRefillWarper;
public static ConfigEntry<int> ColCount;
public static ConfigEntry<int> StackSizeMultiplier;
public static ConfigEntry<bool> DeliveryFirst;
public static ConfigEntry<int> PlayerPackageStackSize;
public static ConfigEntry<int> PlayerPackageStackMultiplier;
public static ConfigEntry<bool> SortToDelieverySlots;
public static ConfigEntry<bool> EnableArchitectMode;
public static ConfigEntry<bool> EnableFastReplicator;
private Harmony harmony;
public void Start()
{
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Expected O, but got Unknown
//IL_0188: Unknown result type (might be due to invalid IL or missing references)
//IL_0192: Expected O, but got Unknown
//IL_0219: Unknown result type (might be due to invalid IL or missing references)
//IL_0225: Expected O, but got Unknown
//IL_025a: Unknown result type (might be due to invalid IL or missing references)
//IL_0266: Expected O, but got Unknown
UseLogisticSlots = ((BaseUnityPlugin)this).Config.Bind<bool>("DeliveryPackage", "UseLogisticSlots", true, "Let replicator and build tools use items in logistic slots.\n使手动制造和建筑工具可以使用物流清单内的物品");
AutoRefillFuel = ((BaseUnityPlugin)this).Config.Bind<bool>("DeliveryPackage", "AutoRefillFuel", false, "Allow fuel chamber to also take from logistics slots.\n自动补充燃料时也会使用物流清单内的物品");
AutoRefillWarper = ((BaseUnityPlugin)this).Config.Bind<bool>("DeliveryPackage", "AutoRefillWarper", false, "Auto refill space warper from inventory and logistics slots.\n从背包和物流清单自动补充翘曲器");
ColCount = ((BaseUnityPlugin)this).Config.Bind<int>("DeliveryPackage", "ColCount", 0, new ConfigDescription("NoChange:0 TechMax:3 Limit:5\n物流清单容量-列(不改:0 原版科技:3 最高上限:5)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 5), Array.Empty<object>()));
StackSizeMultiplier = ((BaseUnityPlugin)this).Config.Bind<int>("DeliveryPackage", "StackSizeMultiplier", 0, "NoChange:0 TechMax:10\n物流清单物品堆叠倍率(不改:0 原版科技:10)");
DeliveryFirst = ((BaseUnityPlugin)this).Config.Bind<bool>("DeliveryPackage", "DeliveryFirst", true, "When logistic bots send items to mecha, send them to delivery slots first.\n配送机会优先将物品送入物流清单的栏位");
SortToDelieverySlots = ((BaseUnityPlugin)this).Config.Bind<bool>("DeliveryPackage", "SortToDelieverySlots", false, "When sorting inventory, send them to delivery slots first.\n整理背包时会先将物品送入物流清单的栏位");
PlayerPackageStackSize = ((BaseUnityPlugin)this).Config.Bind<int>("PlayerPackage", "StackSize", 0, "Overwrite stack size in inventory. NoChange:0\n统一修改玩家背包中的物品堆疊上限(每件物品皆相同)(不改:0)");
PlayerPackageStackMultiplier = ((BaseUnityPlugin)this).Config.Bind<int>("PlayerPackage", "StackMultiplier", 0, "Apply multiplier for stack size in inventory. NoChange:0\n修改玩家背包中的物品堆疊倍率(不改:0)");
EnableArchitectMode = ((BaseUnityPlugin)this).Config.Bind<bool>("BuildTool", "EnableArchitectMode", false, "Build without requirement of items (infinite buildings)\n建筑师模式:建造无需物品");
EnableFastReplicator = ((BaseUnityPlugin)this).Config.Bind<bool>("BuildTool", "EnableFastReplicator", true, "Right click on hotbar to queue the building in replicator\n右键单击快捷栏中的建筑可直接在合成器排程制造");
Instance = this;
Log = ((BaseUnityPlugin)this).Logger;
harmony = new Harmony("starfi5h.plugin.DeliverySlotsTweaks");
Compatibility.Init(harmony);
harmony.PatchAll(typeof(Plugin));
if (UseLogisticSlots.Value)
{
harmony.PatchAll(typeof(DeliveryPackagePatch));
if (AutoRefillFuel.Value)
{
harmony.Patch((MethodBase)AccessTools.Method(typeof(Mecha), "AutoReplenishFuel", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(DeliveryPackagePatch), "TakeItem_Transpiler", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
harmony.Patch((MethodBase)AccessTools.Method(typeof(Mecha), "AutoReplenishFuelAll", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(DeliveryPackagePatch), "TakeItem_Transpiler", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
}
}
StackSizeMultiplier.Value = Math.Min(StackSizeMultiplier.Value, 1000000);
PlayerPackageStackSize.Value = Math.Min(PlayerPackageStackSize.Value, 1000000000);
PlayerPackageStackMultiplier.Value = Math.Min(PlayerPackageStackMultiplier.Value, 1000000);
if (PlayerPackageStackSize.Value > 0 || PlayerPackageStackMultiplier.Value > 0)
{
harmony.PatchAll(typeof(PlayerPackagePatch));
}
if (EnableFastReplicator.Value)
{
harmony.PatchAll(typeof(UIBuildMenuPatch));
}
}
public void OnDestroy()
{
harmony.UnpatchSelf();
harmony = null;
}
[HarmonyPostfix]
[HarmonyPatch(typeof(UIOptionWindow), "OnApplyClick")]
internal static void OnApplyClick()
{
((BaseUnityPlugin)Instance).Config.Reload();
ApplyConfigs();
}
[HarmonyPostfix]
[HarmonyPatch(typeof(Player), "Import")]
[HarmonyPatch(typeof(Player), "SetForNewGame")]
internal static void ApplyConfigs()
{
ParameterOverwrite();
PlayerPackagePatch.OnConfigChange();
Player mainPlayer = GameMain.mainPlayer;
SetMaxDeliveryGridIndex((mainPlayer != null) ? mainPlayer.deliveryPackage : null);
DeliveryPackagePatch.architectMode = EnableArchitectMode.Value;
}
[HarmonyPostfix]
[HarmonyPriority(500)]
[HarmonyPatch(typeof(GameHistoryData), "UnlockTechFunction")]
private static void ParameterOverwrite()
{
Player mainPlayer = GameMain.mainPlayer;
DeliveryPackage val = ((mainPlayer != null) ? mainPlayer.deliveryPackage : null);
if (val != null)
{
if (ColCount.Value > 0 && ColCount.Value <= 5 && val.colCount != ColCount.Value)
{
val.colCount = ColCount.Value;
val.NotifySizeChange();
}
if (StackSizeMultiplier.Value > 0)
{
val.stackSizeMultiplier = StackSizeMultiplier.Value;
}
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(DeliveryPackage), "NotifySizeChange")]
private static void SetMaxDeliveryGridIndex(DeliveryPackage __instance)
{
if (!UseLogisticSlots.Value || __instance == null)
{
return;
}
Player mainPlayer = GameMain.mainPlayer;
if (__instance != ((mainPlayer != null) ? mainPlayer.deliveryPackage : null))
{
return;
}
DeliveryPackagePatch.maxDeliveryGridIndex = 0;
for (int num = __instance.gridLength - 1; num >= 0; num--)
{
if (__instance.IsGridActive(num))
{
DeliveryPackagePatch.maxDeliveryGridIndex = num;
break;
}
}
Log.LogDebug((object)$"DeliveryPackage:{__instance.rowCount}x{__instance.colCount} stack:{__instance.stackSizeMultiplier} maxIndex:{DeliveryPackagePatch.maxDeliveryGridIndex}");
}
[HarmonyPrefix]
[HarmonyPatch(typeof(PlayerPackageUtility), "AddItemToAllPackages")]
private static void AddItemToAllPackages(ref bool deliveryFirst)
{
deliveryFirst = DeliveryFirst.Value;
}
}
public class UIBuildMenuPatch
{
private static bool Initialized;
[HarmonyPostfix]
[HarmonyPatch(typeof(UIBuildMenu), "_OnRegEvent")]
public static void AddEvents(UIBuildMenu __instance)
{
if (Initialized)
{
return;
}
Initialized = true;
for (int i = 0; i < __instance.childButtons.Length; i++)
{
UIButton val = __instance.childButtons[i];
if (!((Object)(object)val == (Object)null))
{
val.data = i;
val.onRightClick += OnChildButtonRightClick;
}
}
}
private static void OnChildButtonRightClick(int index)
{
UIBuildMenu buildMenu = UIRoot.instance.uiGame.buildMenu;
if (UIBuildMenu.protos[buildMenu.currentCategory, index] != null)
{
int iD = ((Proto)UIBuildMenu.protos[buildMenu.currentCategory, index]).ID;
ItemProto val = ((ProtoSet<ItemProto>)(object)LDB.items).Select(iD);
if (val != null && val.maincraft != null)
{
TryReplicateItem(val);
}
}
}
private static void TryReplicateItem(ItemProto itemProto)
{
RecipeProto maincraft = itemProto.maincraft;
if (maincraft == null)
{
return;
}
int iD = ((Proto)maincraft).ID;
int num = 1;
if (!maincraft.Handcraft)
{
UIRealtimeTip.Popup(Localization.Translate("该配方") + maincraft.madeFromString + Localization.Translate("生产"), true, 0);
return;
}
if (!GameMain.history.RecipeUnlocked(iD))
{
UIRealtimeTip.Popup(Localization.Translate("配方未解锁"), true, 0);
return;
}
MechaForge forge = GameMain.mainPlayer.mecha.forge;
int num2 = forge.PredictTaskCount(iD, 99);
if (num > num2)
{
num = num2;
}
if (num == 0)
{
UIRealtimeTip.Popup(Localization.Translate("材料不足"), true, 0);
return;
}
if (forge.AddTask(iD, num) == null)
{
UIRealtimeTip.Popup(Localization.Translate("材料不足"), true, 0);
return;
}
GameMain.history.RegFeatureKey(1000104);
int num3 = 0;
if (maincraft.ResultCounts != null && maincraft.ResultCounts.Length != 0)
{
num3 = maincraft.ResultCounts[0];
}
UIRealtimeTip.Popup(string.Format(Localization.Translate("Crafting {0} [{1}]"), ((Proto)itemProto).name, num3), false, 0);
}
}