feat: ✨ Changed hopper upgrade to filter by contents of the target in…

…ventory when pushing into that inventory and set to filter by contents (instead of the current filtering by source inventory)

gradle.properties

@@ -13,7 +13,7 @@ loader_version_range=[4,)
 mod_id=sophisticatedstorage
 mod_name=Sophisticated Storage
 mod_license=GNU General Public License v3.0
-mod_version=0.10.41
+mod_version=0.10.42
 mod_group_id=sophisticatedstorage
 mod_authors=P3pp3rF1y, Ridanisaurus
 mod_description=Fancy and functional storage containers.
@@ -35,7 +35,7 @@ jade_cf_file_id=5109393
 chipped_cf_file_id=5506938
 resourcefullib_cf_file_id=5483169
 athena_cf_file_id=5431579
-sc_version=[1.21-0.6.41,1.22)
+sc_version=[1.21-0.6.42,1.22)
 sb_version=[1.21,1.22)
 
 #publish

src/main/java/net/p3pp3rf1y/sophisticatedstorage/upgrades/hopper/HopperUpgradeWrapper.java

@@ -21,12 +21,14 @@
 import net.p3pp3rf1y.sophisticatedstorage.block.StorageBlockBase;
 import net.p3pp3rf1y.sophisticatedstorage.block.VerticalFacing;
 import net.p3pp3rf1y.sophisticatedstorage.common.gui.BlockSide;
+import net.p3pp3rf1y.sophisticatedstorage.init.ModBlocks;
 import net.p3pp3rf1y.sophisticatedstorage.init.ModDataComponents;
 import net.p3pp3rf1y.sophisticatedstorage.upgrades.INeighborChangeListenerUpgrade;
 
 import javax.annotation.Nullable;
 import java.lang.ref.WeakReference;
 import java.util.*;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 
@@ -35,17 +37,17 @@ public class HopperUpgradeWrapper extends UpgradeWrapperBase<HopperUpgradeWrappe
 
 	private final Set<Direction> pullDirections = new LinkedHashSet<>();
 	private final Set<Direction> pushDirections = new LinkedHashSet<>();
-	private final Map<Direction, List<BlockCapabilityCache<IItemHandler, Direction>>> handlerCache = new EnumMap<>(Direction.class);
+	private final Map<Direction, ItemHandlerHolder> handlerCache = new EnumMap<>(Direction.class);
 
 	private final ContentsFilterLogic inputFilterLogic;
-	private final ContentsFilterLogic outputFilterLogic;
+	private final TargetContentsFilterLogic outputFilterLogic;
 	private long coolDownTime = 0;
 
 	protected HopperUpgradeWrapper(IStorageWrapper storageWrapper, ItemStack upgrade, Consumer<ItemStack> upgradeSaveHandler) {
 		super(storageWrapper, upgrade, upgradeSaveHandler);
 		inputFilterLogic = new ContentsFilterLogic(upgrade, upgradeSaveHandler, upgradeItem.getInputFilterSlotCount(), storageWrapper::getInventoryHandler,
 				storageWrapper.getSettingsHandler().getTypeCategory(MemorySettingsCategory.class), ModCoreDataComponents.INPUT_FILTER_ATTRIBUTES);
-		outputFilterLogic = new ContentsFilterLogic(upgrade, upgradeSaveHandler, upgradeItem.getOutputFilterSlotCount(), storageWrapper::getInventoryHandler,
+		outputFilterLogic = new TargetContentsFilterLogic(upgrade, upgradeSaveHandler, upgradeItem.getOutputFilterSlotCount(), storageWrapper::getInventoryHandler,
 				storageWrapper.getSettingsHandler().getTypeCategory(MemorySettingsCategory.class), ModDataComponents.OUTPUT_FILTER_ATTRIBUTES);
 
 		deserialize();
@@ -99,6 +101,7 @@ private boolean pullItems(List<IItemHandler> fromHandlers) {
 
 	private boolean pushItems(List<IItemHandler> toHandlers) {
 		for (IItemHandler toHandler : toHandlers) {
+			outputFilterLogic.setInventory(toHandler);
 			if (moveItems(storageWrapper.getInventoryForUpgradeProcessing(), toHandler, outputFilterLogic)) {
 				return true;
 			}
@@ -132,12 +135,14 @@ && needsCacheUpdate(level, pos, direction)) {
 	}
 
 	private boolean needsCacheUpdate(Level level, BlockPos pos, Direction direction) {
-		List<BlockCapabilityCache<IItemHandler, Direction>> handlers = handlerCache.get(direction);
-		if (handlers == null || handlers.isEmpty()) {
+		ItemHandlerHolder holder = handlerCache.get(direction);
+		if (holder == null || holder.handlers().isEmpty()) {
 			return !level.getBlockState(pos).isAir();
+		} else if (holder.refreshOnEveryNeighborChange()) {
+			return true;
 		}
 
-		for (BlockCapabilityCache<IItemHandler, Direction> handler : handlers) {
+		for (BlockCapabilityCache<IItemHandler, Direction> handler : holder.handlers()) {
 			if (handler.getCapability() == null) {
 				return true;
 			}
@@ -159,10 +164,18 @@ public void updateCacheOnSide(Level level, BlockPos pos, Direction direction) {
 
 		List<BlockCapabilityCache<IItemHandler, Direction>> caches = new ArrayList<>();
 
+		AtomicBoolean refreshOnEveryNeighborChange = new AtomicBoolean(false);
 		offsetPositions.forEach(offsetPos -> {
+			offsetPos = level.getBlockEntity(offsetPos, ModBlocks.STORAGE_INPUT_BLOCK_ENTITY_TYPE.get())
+					.flatMap(storageInputBlockEntity -> {
+								refreshOnEveryNeighborChange.set(true);
+								return storageInputBlockEntity.getControllerPos();
+							}
+					).orElse(offsetPos);
+
 			caches.add(BlockCapabilityCache.create(Capabilities.ItemHandler.BLOCK, serverLevel, offsetPos, direction.getOpposite(), () -> existRef.get() != null, () -> updateCacheOnSide(level, pos, direction)));
 		});
-		handlerCache.put(direction, caches);
+		handlerCache.put(direction, new ItemHandlerHolder(caches, refreshOnEveryNeighborChange.get()));
 	}
 
 	private boolean runOnItemHandlers(Level level, BlockPos pos, Direction direction, Predicate<List<IItemHandler>> run) {
@@ -173,7 +186,7 @@ private boolean runOnItemHandlers(Level level, BlockPos pos, Direction direction
 			return false;
 		}
 
-		List<IItemHandler> handler = handlerCache.get(direction).stream().map(BlockCapabilityCache::getCapability).filter(Objects::nonNull).toList();
+		List<IItemHandler> handler = handlerCache.get(direction).handlers().stream().map(BlockCapabilityCache::getCapability).filter(Objects::nonNull).toList();
 
 		return run.test(handler);
 	}
@@ -239,4 +252,8 @@ public void initDirections(Direction pushDirection, Direction pullDirection) {
 		setPushingTo(pushDirection, true);
 		setPullingFrom(pullDirection, true);
 	}
+
+	private record ItemHandlerHolder(List<BlockCapabilityCache<IItemHandler, Direction>> handlers,
+									 boolean refreshOnEveryNeighborChange) {
+	}
 }

src/main/java/net/p3pp3rf1y/sophisticatedstorage/upgrades/hopper/TargetContentsFilterLogic.java

@@ -0,0 +1,53 @@
+package net.p3pp3rf1y.sophisticatedstorage.upgrades.hopper;
+
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+import net.minecraft.core.component.DataComponentType;
+import net.minecraft.world.item.ItemStack;
+import net.neoforged.neoforge.items.IItemHandler;
+import net.neoforged.neoforge.registries.DeferredHolder;
+import net.p3pp3rf1y.sophisticatedcore.inventory.InventoryHandler;
+import net.p3pp3rf1y.sophisticatedcore.inventory.ItemStackKey;
+import net.p3pp3rf1y.sophisticatedcore.settings.memory.MemorySettingsCategory;
+import net.p3pp3rf1y.sophisticatedcore.upgrades.ContentsFilterLogic;
+import net.p3pp3rf1y.sophisticatedcore.upgrades.FilterAttributes;
+import net.p3pp3rf1y.sophisticatedcore.util.InventoryHelper;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class TargetContentsFilterLogic extends ContentsFilterLogic {
+	private Set<ItemStackKey> inventoryFilterStacks = new HashSet<>();
+	private final LoadingCache<IItemHandler, Set<ItemStackKey>> inventoryCache = CacheBuilder.newBuilder().expireAfterWrite(5, TimeUnit.SECONDS).build(new CacheLoader<>() {
+		@Override
+		public Set<ItemStackKey> load(IItemHandler inventory) {
+			return InventoryHelper.getUniqueStacks(inventory);
+		}
+	});
+
+	public TargetContentsFilterLogic(ItemStack upgrade, Consumer<ItemStack> saveHandler, int filterSlotCount, Supplier<InventoryHandler> getInventoryHandler, MemorySettingsCategory memorySettings, DeferredHolder<DataComponentType<?>, DataComponentType<FilterAttributes>> filterAttributesComponent) {
+		super(upgrade, saveHandler, filterSlotCount, getInventoryHandler, memorySettings, filterAttributesComponent);
+	}
+
+	public void setInventory(IItemHandler inventory) {
+		inventoryFilterStacks = inventoryCache.getUnchecked(inventory);
+	}
+
+	@Override
+	public boolean matchesFilter(ItemStack stack) {
+		if (!shouldFilterByStorage()) {
+			return super.matchesFilter(stack);
+		}
+
+		for (ItemStackKey filterStack : inventoryFilterStacks) {
+			if (stackMatchesFilter(stack, filterStack.getStack())) {
+				return true;
+			}
+		}
+		return false;
+	}
+}