Filter Cover Directionality

src/main/java/com/gregtechceu/gtceu/api/cover/filter/SimpleItemFilter.java

@@ -125,9 +125,9 @@ public void detectAndSendChanges() {
                 group.addWidget(slot);
             }
         }
-        group.addWidget(new ToggleButtonWidget(18 * 3 + 2, 9, 18, 18,
+        group.addWidget(new ToggleButtonWidget(18 * 3 + 5, 0, 20, 20,
                 GuiTextures.BUTTON_BLACKLIST, this::isBlackList, this::setBlackList));
-        group.addWidget(new ToggleButtonWidget(18 * 3 + 2, (18) + 9, 18, 18,
+        group.addWidget(new ToggleButtonWidget(18 * 3 + 5, 20, 20, 20,
                 GuiTextures.BUTTON_FILTER_NBT, this::isIgnoreNbt, this::setIgnoreNbt));
         return group;
     }

src/main/java/com/gregtechceu/gtceu/api/machine/MetaMachine.java

@@ -662,11 +662,10 @@ public Predicate<ItemStack> getItemCapFilter(@Nullable Direction side, IO io) {
         return item -> true;
     }
 
-    // TODO: ADD Fluid Filter Modes
-    public Predicate<FluidStack> getFluidCapFilter(@Nullable Direction side) {
+    public Predicate<FluidStack> getFluidCapFilter(@Nullable Direction side, IO io) {
         if (side != null) {
             var cover = getCoverContainer().getCoverAtSide(side);
-            if (cover instanceof FluidFilterCover filterCover) {
+            if (cover instanceof FluidFilterCover filterCover && filterCover.getFilterMode().filters(io)) {
                 return filterCover.getFluidFilter();
             }
         }
@@ -713,7 +712,8 @@ public IFluidHandlerModifiable getFluidHandlerCap(@Nullable Direction side, bool
             io = IO.OUT;
         }
 
-        IOFluidHandlerList handlerList = new IOFluidHandlerList(list, io, getFluidCapFilter(side));
+        IOFluidHandlerList handlerList = new IOFluidHandlerList(list, io, getFluidCapFilter(side, IO.IN),
+                getFluidCapFilter(side, IO.OUT));
         if (!useCoverCapability || side == null) return handlerList;
 
         CoverBehavior cover = getCoverContainer().getCoverAtSide(side);

src/main/java/com/gregtechceu/gtceu/api/machine/trait/FluidTankProxyTrait.java

@@ -135,7 +135,7 @@ public void exportToNearby(Direction... facings) {
         var level = getMachine().getLevel();
         var pos = getMachine().getPos();
         for (Direction facing : facings) {
-            var filter = getMachine().getFluidCapFilter(facing);
+            var filter = getMachine().getFluidCapFilter(facing, IO.OUT);
             GTTransferUtils.getAdjacentFluidHandler(level, pos, facing)
                     .ifPresent(adj -> GTTransferUtils.transferFluidsFiltered(this, adj, filter));
         }

src/main/java/com/gregtechceu/gtceu/api/machine/trait/NotifiableFluidTank.java

@@ -284,7 +284,7 @@ public void exportToNearby(@NotNull Direction... facings) {
         var level = getMachine().getLevel();
         var pos = getMachine().getPos();
         for (Direction facing : facings) {
-            var filter = getMachine().getFluidCapFilter(facing);
+            var filter = getMachine().getFluidCapFilter(facing, IO.OUT);
             GTTransferUtils.getAdjacentFluidHandler(level, pos, facing)
                     .ifPresent(adj -> GTTransferUtils.transferFluidsFiltered(this, adj, filter));
         }
@@ -294,7 +294,7 @@ public void importFromNearby(@NotNull Direction... facings) {
         var level = getMachine().getLevel();
         var pos = getMachine().getPos();
         for (Direction facing : facings) {
-            var filter = getMachine().getFluidCapFilter(facing);
+            var filter = getMachine().getFluidCapFilter(facing, IO.IN);
             GTTransferUtils.getAdjacentFluidHandler(level, pos, facing)
                     .ifPresent(adj -> GTTransferUtils.transferFluidsFiltered(adj, this, filter));
         }

src/main/java/com/gregtechceu/gtceu/api/misc/IOFluidHandlerList.java

@@ -22,29 +22,43 @@ public class IOFluidHandlerList extends FluidHandlerList implements IFluidHandle
 
     @Getter
     private final IO io;
+    private final Predicate<FluidStack> inFilter;
+    private final Predicate<FluidStack> outFilter;
 
-    public IOFluidHandlerList(List<IFluidHandler> handlers, IO io, Predicate<FluidStack> filter) {
+    public IOFluidHandlerList(List<IFluidHandler> handlers, IO io, Predicate<FluidStack> inFilter,
+                              Predicate<FluidStack> outFilter) {
         super(handlers);
         this.io = io;
-        setFilter(filter);
+        this.inFilter = inFilter;
+        this.outFilter = outFilter;
     }
 
     @Override
     public int fill(FluidStack resource, FluidAction action) {
-        if (io != IO.IN && io != IO.BOTH) return 0;
+        if (!io.support(IO.IN) || !inFilter.test(resource)) return 0;
         return super.fill(resource, action);
     }
 
     @Override
     public @NotNull FluidStack drain(FluidStack resource, FluidAction action) {
-        if (io != IO.OUT && io != IO.BOTH) return FluidStack.EMPTY;
+        if (!io.support(IO.OUT) || !outFilter.test(resource)) return FluidStack.EMPTY;
         return super.drain(resource, action);
     }
 
     @Override
     public @NotNull FluidStack drain(int maxDrain, FluidAction action) {
-        if (io != IO.OUT && io != IO.BOTH) return FluidStack.EMPTY;
-        return super.drain(maxDrain, action);
+        if (!io.support(IO.OUT)) return FluidStack.EMPTY;
+        var fluidStack = super.drain(maxDrain, FluidAction.SIMULATE);
+        if (fluidStack.isEmpty() || !outFilter.test(fluidStack)) return FluidStack.EMPTY;
+        return action.simulate() ? fluidStack : super.drain(maxDrain, action);
+    }
+
+    @Override
+    public boolean isFluidValid(int tank, @NotNull FluidStack stack) {
+        Predicate<FluidStack> filter = s -> true;
+        if (io.support(IO.IN)) filter = inFilter.and(filter);
+        if (io.support(IO.OUT)) filter = outFilter.and(filter);
+        return filter.test(stack) && super.isFluidValid(tank, stack);
     }
 
     @Override

src/main/java/com/gregtechceu/gtceu/common/blockentity/FluidPipeBlockEntity.java

@@ -4,6 +4,7 @@
 import com.gregtechceu.gtceu.api.blockentity.PipeBlockEntity;
 import com.gregtechceu.gtceu.api.capability.ICoverable;
 import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
+import com.gregtechceu.gtceu.api.capability.recipe.IO;
 import com.gregtechceu.gtceu.api.cover.CoverBehavior;
 import com.gregtechceu.gtceu.api.data.chemical.material.properties.FluidPipeProperties;
 import com.gregtechceu.gtceu.api.fluids.FluidConstants;
@@ -12,8 +13,10 @@
 import com.gregtechceu.gtceu.api.fluids.attribute.FluidAttribute;
 import com.gregtechceu.gtceu.api.machine.TickableSubscription;
 import com.gregtechceu.gtceu.api.machine.feature.IDataInfoProvider;
+import com.gregtechceu.gtceu.api.misc.IOFluidHandlerList;
 import com.gregtechceu.gtceu.api.transfer.fluid.CustomFluidTank;
 import com.gregtechceu.gtceu.api.transfer.fluid.IFluidHandlerModifiable;
+import com.gregtechceu.gtceu.common.cover.FluidFilterCover;
 import com.gregtechceu.gtceu.common.cover.PumpCover;
 import com.gregtechceu.gtceu.common.cover.data.ManualIOMode;
 import com.gregtechceu.gtceu.common.item.PortableScannerBehavior;
@@ -58,6 +61,7 @@
 import java.util.ArrayList;
 import java.util.EnumMap;
 import java.util.List;
+import java.util.function.Predicate;
 
 public class FluidPipeBlockEntity extends PipeBlockEntity<FluidPipeType, FluidPipeProperties>
                                   implements IDataInfoProvider {
@@ -111,6 +115,16 @@ public boolean canAttachTo(Direction side) {
         return false;
     }
 
+    private Predicate<FluidStack> getFluidCapFilter(@Nullable Direction side, IO io) {
+        if (side != null) {
+            var cover = getCoverContainer().getCoverAtSide(side);
+            if (cover instanceof FluidFilterCover filterCover && filterCover.getFilterMode().filters(io)) {
+                return filterCover.getFluidFilter();
+            }
+        }
+        return fluid -> true;
+    }
+
     @NotNull
     @Override
     public <T> LazyOptional<T> getCapability(Capability<T> capability, @Nullable Direction facing) {
@@ -119,8 +133,11 @@ public <T> LazyOptional<T> getCapability(Capability<T> capability, @Nullable Dir
                 PipeTankList tankList = getTankList(facing);
                 if (tankList == null)
                     return LazyOptional.empty();
+
+                IOFluidHandlerList list = new IOFluidHandlerList(List.of(tankList), IO.BOTH,
+                        getFluidCapFilter(facing, IO.IN), getFluidCapFilter(facing, IO.OUT));
                 return ForgeCapabilities.FLUID_HANDLER.orEmpty(capability,
-                        LazyOptional.of(() -> tankList));
+                        LazyOptional.of(() -> list));
             }
         } else if (capability == GTCapability.CAPABILITY_COVERABLE) {
             return GTCapability.CAPABILITY_COVERABLE.orEmpty(capability, LazyOptional.of(this::getCoverContainer));
@@ -228,11 +245,8 @@ private void distributeFluid(int channel, CustomFluidTank tank, FluidStack fluid
         // Now distribute
         for (FluidTransaction transaction : tanks) {
             if (availableCapacity > maxAmount) {
-                transaction.amount = Mth.floor(transaction.amount * maxAmount / availableCapacity); // Distribute fluids
-                                                                                                    // based on
-                                                                                                    // percentage
-                                                                                                    // available space
-                                                                                                    // at destination
+                // Distribute fluids based on percentage available space at destination
+                transaction.amount = Mth.floor(transaction.amount * maxAmount / availableCapacity);
             }
             if (transaction.amount == 0) {
                 if (tank.getFluidAmount() <= 0) break; // If there is no more stored fluid, stop transferring to prevent

src/main/java/com/gregtechceu/gtceu/common/cover/FluidFilterCover.java

@@ -5,18 +5,26 @@
 import com.gregtechceu.gtceu.api.cover.CoverDefinition;
 import com.gregtechceu.gtceu.api.cover.IUICover;
 import com.gregtechceu.gtceu.api.cover.filter.FluidFilter;
+import com.gregtechceu.gtceu.api.gui.widget.EnumSelectorWidget;
 import com.gregtechceu.gtceu.api.transfer.fluid.FluidHandlerDelegate;
 import com.gregtechceu.gtceu.api.transfer.fluid.IFluidHandlerModifiable;
+import com.gregtechceu.gtceu.common.cover.data.FilterMode;
+import com.gregtechceu.gtceu.common.cover.data.ManualIOMode;
 
 import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
 import com.lowdragmc.lowdraglib.gui.widget.Widget;
 import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
+import com.lowdragmc.lowdraglib.syncdata.annotation.DescSynced;
+import com.lowdragmc.lowdraglib.syncdata.annotation.Persisted;
+import com.lowdragmc.lowdraglib.syncdata.field.ManagedFieldHolder;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.Direction;
 import net.minecraftforge.fluids.FluidStack;
 import net.minecraftforge.fluids.FluidUtil;
 
+import lombok.Getter;
+import lombok.Setter;
 import org.jetbrains.annotations.Nullable;
 
 import javax.annotation.ParametersAreNonnullByDefault;
@@ -30,13 +38,27 @@
 @MethodsReturnNonnullByDefault
 public class FluidFilterCover extends CoverBehavior implements IUICover {
 
+    public static final ManagedFieldHolder MANAGED_FIELD_HOLDER = new ManagedFieldHolder(FluidFilterCover.class,
+            CoverBehavior.MANAGED_FIELD_HOLDER);
     protected FluidFilter fluidFilter;
+    @Persisted
+    @DescSynced
+    @Getter
+    protected FilterMode filterMode = FilterMode.FILTER_INSERT;
     private FilteredFluidHandlerWrapper fluidFilterWrapper;
+    @Setter
+    @Getter
+    protected ManualIOMode allowFlow = ManualIOMode.DISABLED;
 
     public FluidFilterCover(CoverDefinition definition, ICoverable coverHolder, Direction attachedSide) {
         super(definition, coverHolder, attachedSide);
     }
 
+    public void setFilterMode(FilterMode filterMode) {
+        this.filterMode = filterMode;
+        coverHolder.markDirty();
+    }
+
     @Override
     public boolean canAttach() {
         return FluidUtil.getFluidHandler(coverHolder.getLevel(), coverHolder.getPos(), attachedSide).isPresent();
@@ -64,12 +86,20 @@ public FluidFilter getFluidFilter() {
 
     @Override
     public Widget createUIWidget() {
-        final var group = new WidgetGroup(0, 0, 120, 85);
-        group.addWidget(new LabelWidget(5, 5, attachItem.getDescriptionId()));
-        group.addWidget(getFluidFilter().openConfigurator(25, 25));
+        final var group = new WidgetGroup(0, 0, 178, 85);
+        group.addWidget(new LabelWidget(60, 5, attachItem.getDescriptionId()));
+        group.addWidget(new EnumSelectorWidget<>(35, 25, 18, 18,
+                FilterMode.VALUES, filterMode, this::setFilterMode));
+        group.addWidget(new EnumSelectorWidget<>(35, 45, 18, 18, ManualIOMode.VALUES, allowFlow, this::setAllowFlow));
+        group.addWidget(getFluidFilter().openConfigurator(62, 25));
         return group;
     }
 
+    @Override
+    public ManagedFieldHolder getFieldHolder() {
+        return MANAGED_FIELD_HOLDER;
+    }
+
     private class FilteredFluidHandlerWrapper extends FluidHandlerDelegate {
 
         public FilteredFluidHandlerWrapper(IFluidHandlerModifiable delegate) {
@@ -78,16 +108,20 @@ public FilteredFluidHandlerWrapper(IFluidHandlerModifiable delegate) {
 
         @Override
         public int fill(FluidStack resource, FluidAction action) {
-            if (!getFluidFilter().test(resource))
-                return 0;
-            return super.fill(resource, action);
+            if ((filterMode == FilterMode.FILTER_EXTRACT) && allowFlow == ManualIOMode.UNFILTERED)
+                return super.fill(resource, action);
+            if (filterMode != FilterMode.FILTER_EXTRACT && getFluidFilter().test(resource))
+                return super.fill(resource, action);
+            return 0;
         }
 
         @Override
         public FluidStack drain(FluidStack resource, FluidAction action) {
-            if (!getFluidFilter().test(resource))
-                return FluidStack.EMPTY;
-            return super.drain(resource, action);
+            if ((filterMode == FilterMode.FILTER_INSERT) && allowFlow == ManualIOMode.UNFILTERED)
+                return super.drain(resource, action);
+            if (filterMode != FilterMode.FILTER_INSERT && getFluidFilter().test(resource))
+                return super.drain(resource, action);
+            return FluidStack.EMPTY;
         }
     }
 }

src/main/java/com/gregtechceu/gtceu/common/cover/ItemFilterCover.java

@@ -10,7 +10,8 @@
 import com.gregtechceu.gtceu.api.machine.MachineCoverContainer;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
 import com.gregtechceu.gtceu.api.transfer.item.ItemHandlerDelegate;
-import com.gregtechceu.gtceu.common.cover.data.ItemFilterMode;
+import com.gregtechceu.gtceu.common.cover.data.FilterMode;
+import com.gregtechceu.gtceu.common.cover.data.ManualIOMode;
 import com.gregtechceu.gtceu.utils.GTTransferUtils;
 
 import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
@@ -27,6 +28,7 @@
 import net.minecraftforge.items.IItemHandlerModifiable;
 
 import lombok.Getter;
+import lombok.Setter;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -48,8 +50,11 @@ public class ItemFilterCover extends CoverBehavior implements IUICover {
     @Persisted
     @DescSynced
     @Getter
-    protected ItemFilterMode filterMode = ItemFilterMode.FILTER_INSERT;
+    protected FilterMode filterMode = FilterMode.FILTER_INSERT;
     private FilteredItemHandlerWrapper itemFilterWrapper;
+    @Setter
+    @Getter
+    protected ManualIOMode allowFlow = ManualIOMode.DISABLED;
 
     public ItemFilterCover(CoverDefinition definition, ICoverable coverHolder, Direction attachedSide) {
         super(definition, coverHolder, attachedSide);
@@ -66,7 +71,7 @@ public ItemFilter getItemFilter() {
         return itemFilter;
     }
 
-    public void setFilterMode(ItemFilterMode filterMode) {
+    public void setFilterMode(FilterMode filterMode) {
         this.filterMode = filterMode;
         coverHolder.markDirty();
     }
@@ -94,11 +99,12 @@ public void onAttached(ItemStack itemStack, ServerPlayer player) {
 
     @Override
     public Widget createUIWidget() {
-        final var group = new WidgetGroup(0, 0, 120, 85);
-        group.addWidget(new LabelWidget(5, 5, attachItem.getDescriptionId()));
-        group.addWidget(new EnumSelectorWidget<>(7, 61, 18, 18,
-                ItemFilterMode.VALUES, filterMode, this::setFilterMode));
-        group.addWidget(getItemFilter().openConfigurator(30, 25));
+        final var group = new WidgetGroup(0, 0, 178, 85);
+        group.addWidget(new LabelWidget(60, 5, attachItem.getDescriptionId()));
+        group.addWidget(new EnumSelectorWidget<>(35, 25, 18, 18,
+                FilterMode.VALUES, filterMode, this::setFilterMode));
+        group.addWidget(new EnumSelectorWidget<>(35, 45, 18, 18, ManualIOMode.VALUES, allowFlow, this::setAllowFlow));
+        group.addWidget(getItemFilter().openConfigurator(62, 25));
         return group;
     }
 
@@ -115,18 +121,25 @@ public FilteredItemHandlerWrapper(IItemHandlerModifiable delegate) {
 
         @Override
         public @NotNull ItemStack insertItem(int slot, @NotNull ItemStack stack, boolean simulate) {
-            if (filterMode != ItemFilterMode.FILTER_EXTRACT && !getItemFilter().test(stack))
-                return stack;
-            return super.insertItem(slot, stack, simulate);
+            if ((filterMode == FilterMode.FILTER_EXTRACT) && allowFlow == ManualIOMode.UNFILTERED)
+                return super.insertItem(slot, stack, simulate);
+            if (filterMode != FilterMode.FILTER_EXTRACT && getItemFilter().test(stack)) {
+                return super.insertItem(slot, stack, simulate);
+            }
+            return stack;
         }
 
         @Override
         public @NotNull ItemStack extractItem(int slot, int amount, boolean simulate) {
             ItemStack result = super.extractItem(slot, amount, true);
-            if (result.isEmpty() || (filterMode != ItemFilterMode.FILTER_INSERT && !getItemFilter().test(result))) {
-                return ItemStack.EMPTY;
+            if (result.isEmpty() && (filterMode == FilterMode.FILTER_INSERT) && allowFlow == ManualIOMode.UNFILTERED) {
+                return super.extractItem(slot, amount, false);
+            }
+
+            if (filterMode != FilterMode.FILTER_INSERT && getItemFilter().test(result)) {
+                return super.extractItem(slot, amount, false);
             }
-            return simulate ? result : super.extractItem(slot, amount, false);
+            return ItemStack.EMPTY;
         }
     }
 }