Merge branch '1.19' into 1.18

# Conflicts: # build.gradle.kts # settings.gradle.kts # src/main/java/gripe/_90/aecapfix/mixin/ae2/ChestBlockEntityMixin.java # src/main/java/gripe/_90/aecapfix/mixin/ae2/InitCapabilitiesMixin.java # src/main/java/gripe/_90/aecapfix/mixin/powah/ForgeEnvHandlerMixin.java
62832 · Dec 28, 2023 · ff2e793 · ff2e793
2 parents d8f86c3 + fda4df4
commit ff2e793
Show file tree

Hide file tree

Showing 9 changed files with 64 additions and 39 deletions.
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -157,6 +157,8 @@ spotless {
     json {
         target("src/*/resources/**/*.json")
         targetExclude("src/generated/resources/**")
-        prettier().config(mapOf("parser" to "json"))
+        biome()
+        indentWithSpaces(2)
+        endWithNewline()
     }
 }
diff --git a/settings.gradle.kts b/settings.gradle.kts
@@ -14,7 +14,7 @@ dependencyResolutionManagement {
         create("libs") {
             plugin("forge", "net.minecraftforge.gradle").version("6.0.+")
             plugin("mixin", "org.spongepowered.mixin").version("0.7.+")
-            plugin("spotless", "com.diffplug.spotless").version("6.20.0")
+            plugin("spotless", "com.diffplug.spotless").version("6.23.3")
 
             val minecraftVersion = "1.18.2"
             version("minecraft", minecraftVersion)

diff --git a/src/main/java/gripe/_90/aecapfix/misc/DirectionalCapabilityCache.java b/src/main/java/gripe/_90/aecapfix/misc/DirectionalCapabilityCache.java
@@ -0,0 +1,34 @@
+package gripe._90.aecapfix.misc;
+
+import java.util.HashMap;
+import java.util.Map;
+import net.minecraft.core.Direction;
+import net.minecraftforge.common.util.LazyOptional;
+
+public class DirectionalCapabilityCache<C> {
+    private final Map<Direction, LazyOptional<C>> directional = new HashMap<>();
+    private LazyOptional<C> nullDirection = LazyOptional.empty();
+
+    public LazyOptional<C> getOrCache(Direction side, LazyOptional<?> toCache) {
+        if (toCache.isPresent()) {
+            if (side == null) {
+                if (!nullDirection.isPresent()) {
+                    nullDirection = toCache.cast();
+                }
+
+                return nullDirection;
+            } else {
+                directional.putIfAbsent(side, toCache.cast());
+                return directional.get(side);
+            }
+        } else {
+            return LazyOptional.empty();
+        }
+    }
+
+    public void invalidate() {
+        directional.forEach((direction, holder) -> holder.invalidate());
+        directional.clear();
+        nullDirection.invalidate();
+    }
+}
diff --git a/src/main/java/gripe/_90/aecapfix/mixin/ae2/InitCapabilitiesMixin.java b/src/main/java/gripe/_90/aecapfix/mixin/ae2/InitCapabilitiesMixin.java
@@ -5,16 +5,17 @@
 import appeng.helpers.externalstorage.GenericStackFluidStorage;
 import appeng.helpers.externalstorage.GenericStackItemStorage;
 import appeng.init.InitCapabilities;
-import java.util.HashSet;
-import java.util.Set;
+import gripe._90.aecapfix.misc.DirectionalCapabilityCache;
 import net.minecraft.core.Direction;
 import net.minecraft.world.level.block.entity.BlockEntity;
 import net.minecraftforge.common.capabilities.Capability;
 import net.minecraftforge.common.capabilities.ICapabilityProvider;
 import net.minecraftforge.common.util.LazyOptional;
 import net.minecraftforge.event.AttachCapabilitiesEvent;
 import net.minecraftforge.fluids.capability.CapabilityFluidHandler;
+import net.minecraftforge.fluids.capability.IFluidHandler;
 import net.minecraftforge.items.CapabilityItemHandler;
+import net.minecraftforge.items.IItemHandler;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.spongepowered.asm.mixin.Mixin;
@@ -32,33 +33,28 @@ private static void registerCapabilities(AttachCapabilitiesEvent<BlockEntity> ev
         var provider = new ICapabilityProvider() {
             private final BlockEntity be = event.getObject();
 
-            private final Set<LazyOptional<GenericStackItemStorage>> itemHandlers = new HashSet<>();
-            private final Set<LazyOptional<GenericStackFluidStorage>> fluidHandlers = new HashSet<>();
+            private final DirectionalCapabilityCache<IItemHandler> itemHandlers = new DirectionalCapabilityCache<>();
+            private final DirectionalCapabilityCache<IFluidHandler> fluidHandlers = new DirectionalCapabilityCache<>();
 
             @NotNull
             @Override
             public <T> LazyOptional<T> getCapability(@NotNull Capability<T> cap, @Nullable Direction side) {
                 if (cap == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) {
-                    var handler = be.getCapability(Capabilities.GENERIC_INTERNAL_INV, side)
+                    var holder = be.getCapability(Capabilities.GENERIC_INTERNAL_INV, side)
                             .lazyMap(GenericStackItemStorage::new);
-                    itemHandlers.add(handler);
-                    return handler.cast();
+                    return itemHandlers.getOrCache(side, holder).cast();
                 } else if (cap == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY) {
-                    var handler = be.getCapability(Capabilities.GENERIC_INTERNAL_INV, side)
+                    var holder = be.getCapability(Capabilities.GENERIC_INTERNAL_INV, side)
                             .lazyMap(GenericStackFluidStorage::new);
-                    fluidHandlers.add(handler);
-                    return handler.cast();
+                    return fluidHandlers.getOrCache(side, holder).cast();
                 } else {
                     return LazyOptional.empty();
                 }
             }
 
             private void invalidate() {
-                itemHandlers.forEach(LazyOptional::invalidate);
-                fluidHandlers.forEach(LazyOptional::invalidate);
-
-                itemHandlers.clear();
-                fluidHandlers.clear();
+                itemHandlers.invalidate();
+                fluidHandlers.invalidate();
             }
         };
 

diff --git a/src/main/java/gripe/_90/aecapfix/mixin/ae2/PatternProviderBlockEntityMixin.java b/src/main/java/gripe/_90/aecapfix/mixin/ae2/PatternProviderBlockEntityMixin.java
@@ -1,7 +1,7 @@
 package gripe._90.aecapfix.mixin.ae2;
 
 import appeng.blockentity.crafting.PatternProviderBlockEntity;
-import appeng.helpers.iface.PatternProviderLogic;
+import appeng.helpers.patternprovider.PatternProviderLogic;
 import gripe._90.aecapfix.AECapFix;
 import net.minecraft.core.BlockPos;
 import net.minecraft.world.level.block.entity.BlockEntity;

diff --git a/src/main/java/gripe/_90/aecapfix/mixin/ae2/PatternProviderLogicMixin.java b/src/main/java/gripe/_90/aecapfix/mixin/ae2/PatternProviderLogicMixin.java
@@ -1,7 +1,7 @@
 package gripe._90.aecapfix.mixin.ae2;
 
-import appeng.helpers.iface.PatternProviderLogic;
-import appeng.helpers.iface.PatternProviderReturnInventory;
+import appeng.helpers.patternprovider.PatternProviderLogic;
+import appeng.helpers.patternprovider.PatternProviderReturnInventory;
 import gripe._90.aecapfix.AECapFix;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;

diff --git a/src/main/java/gripe/_90/aecapfix/mixin/ae2/PatternProviderPartMixin.java b/src/main/java/gripe/_90/aecapfix/mixin/ae2/PatternProviderPartMixin.java
@@ -1,6 +1,6 @@
 package gripe._90.aecapfix.mixin.ae2;
 
-import appeng.helpers.iface.PatternProviderLogic;
+import appeng.helpers.patternprovider.PatternProviderLogic;
 import appeng.parts.crafting.PatternProviderPart;
 import gripe._90.aecapfix.AECapFix;
 import org.spongepowered.asm.mixin.Final;

diff --git a/src/main/java/gripe/_90/aecapfix/mixin/ae2/PatternProviderReturnInventoryMixin.java b/src/main/java/gripe/_90/aecapfix/mixin/ae2/PatternProviderReturnInventoryMixin.java
@@ -1,7 +1,7 @@
 package gripe._90.aecapfix.mixin.ae2;
 
 import appeng.api.behaviors.GenericInternalInventory;
-import appeng.helpers.iface.PatternProviderReturnInventory;
+import appeng.helpers.patternprovider.PatternProviderReturnInventory;
 import gripe._90.aecapfix.AECapFix;
 import net.minecraftforge.common.util.LazyOptional;
 import org.spongepowered.asm.mixin.Final;

diff --git a/src/main/java/gripe/_90/aecapfix/mixin/powah/ForgeEnvHandlerMixin.java b/src/main/java/gripe/_90/aecapfix/mixin/powah/ForgeEnvHandlerMixin.java
@@ -1,8 +1,7 @@
 package gripe._90.aecapfix.mixin.powah;
 
+import gripe._90.aecapfix.misc.DirectionalCapabilityCache;
 import gripe._90.aecapfix.misc.PowahEnergyStorage;
-import java.util.HashSet;
-import java.util.Set;
 import net.minecraft.core.Direction;
 import net.minecraft.world.level.block.entity.BlockEntity;
 import net.minecraftforge.common.capabilities.Capability;
@@ -36,23 +35,19 @@ private void registerCapabilities(AttachCapabilitiesEvent<BlockEntity> event, Ca
 
         if (event.getObject() instanceof ReactorPartTile reactorPart) {
             var provider = new ICapabilityProvider() {
-                private final Set<LazyOptional<Object>> holders = new HashSet<>();
+                private final DirectionalCapabilityCache<Object> cache = new DirectionalCapabilityCache<>();
 
                 @NotNull
                 @Override
                 public <T> LazyOptional<T> getCapability(@NotNull Capability<T> cap, @Nullable Direction side) {
-                    if (reactorPart.core().isEmpty() || cap == CapabilityEnergy.ENERGY && !reactorPart.isExtractor()) {
-                        return LazyOptional.empty();
-                    }
-
-                    var holder = reactorPart.core().get().getCapability(cap, side);
-                    holders.add(holder.cast());
-                    return holder;
+                    return reactorPart.core().isEmpty() || cap == CapabilityEnergy.ENERGY && !reactorPart.isExtractor()
+                            ? LazyOptional.empty()
+                            : cache.getOrCache(side, reactorPart.core().get().getCapability(cap, side))
+                                    .cast();
                 }
 
                 private void invalidate() {
-                    holders.forEach(LazyOptional::invalidate);
-                    holders.clear();
+                    cache.invalidate();
                 }
             };
 
@@ -62,23 +57,21 @@ private void invalidate() {
 
         if (event.getObject() instanceof AbstractEnergyStorage<?, ?> energyStorage) {
             var provider = new ICapabilityProvider() {
-                private final Set<LazyOptional<IEnergyStorage>> holders = new HashSet<>();
+                private final DirectionalCapabilityCache<IEnergyStorage> cache = new DirectionalCapabilityCache<>();
 
                 @NotNull
                 @Override
                 public <T> LazyOptional<T> getCapability(@NotNull Capability<T> cap, @Nullable Direction side) {
                     if (cap == CapabilityEnergy.ENERGY && energyStorage.isEnergyPresent(side)) {
                         var holder = LazyOptional.of(() -> new PowahEnergyStorage(energyStorage, side));
-                        holders.add(holder.cast());
-                        return holder.cast();
+                        return cache.getOrCache(side, holder).cast();
                     }
 
                     return LazyOptional.empty();
                 }
 
                 private void invalidate() {
-                    holders.forEach(LazyOptional::invalidate);
-                    holders.clear();
+                    cache.invalidate();
                 }
             };