greedy stack transfers

Patches/StackMoveGreedyPatches.cs

@@ -0,0 +1,87 @@
+using Aki.Reflection.Patching;
+using EFT.UI.DragAndDrop;
+using HarmonyLib;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace UIFixes
+{
+    public static class StackMoveGreedyPatches
+    {
+        private static bool InPatch = false;
+
+        public static void Enable()
+        {
+            new GridViewPatch().Enable();
+            new SlotViewPatch().Enable();
+        }
+
+        public class GridViewPatch : ModulePatch
+        {
+            protected override MethodBase GetTargetMethod()
+            {
+                return AccessTools.Method(typeof(GridView), nameof(GridView.AcceptItem));
+            }
+
+            [PatchPrefix]
+            [HarmonyPriority(Priority.LowerThanNormal)]
+            public static bool Prefix(GridView __instance, ItemContextClass itemContext, ItemContextAbstractClass targetItemContext, ref Task __result)
+            {
+                return AcceptStackable(__instance, itemContext, targetItemContext, ref __result);
+            }
+        }
+
+        public class SlotViewPatch : ModulePatch
+        {
+            protected override MethodBase GetTargetMethod()
+            {
+                return AccessTools.Method(typeof(SlotView), nameof(SlotView.AcceptItem));
+            }
+
+            [PatchPrefix]
+            [HarmonyPriority(Priority.LowerThanNormal)]
+            public static bool Prefix(SlotView __instance, ItemContextClass itemContext, ItemContextAbstractClass targetItemContext, ref Task __result)
+            {
+                return AcceptStackable(__instance, itemContext, targetItemContext, ref __result);
+            }
+        }
+
+        private static bool AcceptStackable<T>(T __instance, ItemContextClass itemContext, ItemContextAbstractClass targetItemContext, ref Task __result) where T : MonoBehaviour, IContainer
+        {
+            if (!Settings.GreedyStackMove.Value || InPatch || itemContext.Item.StackObjectsCount <= 1 || targetItemContext == null)
+            {
+                return true;
+            }
+
+            InPatch = true;
+
+            int stackCount = int.MaxValue;
+            var serializer = __instance.gameObject.AddComponent<ItemContextTaskSerializer>();
+            __result = serializer.Initialize(itemContext.RepeatUntilEmpty(), ic =>
+            {
+                if (ic.Item.StackObjectsCount >= stackCount)
+                {
+                    // Nothing happened, bail out
+                    return Task.FromCanceled(new CancellationToken(true));
+                }
+
+                stackCount = ic.Item.StackObjectsCount;
+                return __instance.AcceptItem(ic, targetItemContext);
+            });
+
+            // This won't block the first action from swapping, but will prevent follow up swaps
+            SwapPatches.BlockSwaps = true;
+
+            __result.ContinueWith(_ => 
+            { 
+                InPatch = false; 
+                SwapPatches.BlockSwaps = false;
+            });
+
+            return false;
+        }
+    }
+}