It's 3am

src/main/java/net/nussi/dedicated_applied_energistics/blockentities/InterDimensionalInterfaceBlockEntity.java

@@ -1,53 +1,156 @@
 package net.nussi.dedicated_applied_energistics.blockentities;
 
+import appeng.api.crafting.IPatternDetails;
+import appeng.api.networking.GridFlags;
+import appeng.api.networking.IGridNode;
+import appeng.api.networking.crafting.CalculationStrategy;
+import appeng.api.networking.crafting.ICraftingProvider;
+import appeng.api.networking.crafting.ICraftingSimulationRequester;
+import appeng.api.networking.security.IActionHost;
+import appeng.api.networking.security.IActionSource;
+import appeng.api.networking.ticking.IGridTickable;
+import appeng.api.networking.ticking.TickRateModulation;
+import appeng.api.networking.ticking.TickingRequest;
 import appeng.api.stacks.AEItemKey;
+import appeng.api.stacks.KeyCounter;
 import appeng.blockentity.crafting.PatternProviderBlockEntity;
-import appeng.helpers.iface.PatternProviderLogic;
+import appeng.blockentity.grid.AENetworkBlockEntity;
+import appeng.core.settings.TickRates;
 import com.mojang.logging.LogUtils;
 import net.minecraft.core.BlockPos;
-import net.minecraft.world.item.ItemStack;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.level.block.state.BlockState;
 import net.nussi.dedicated_applied_energistics.init.BlockEntityTypeInit;
 import net.nussi.dedicated_applied_energistics.init.ItemInit;
-import net.nussi.dedicated_applied_energistics.providers.InterDimensionalInterfacePatternProvider;
+import net.nussi.dedicated_applied_energistics.providers.NetworkPattern;
+import net.nussi.dedicated_applied_energistics.providers.NetworkPatternList;
+import org.jetbrains.annotations.Nullable;
 import org.slf4j.Logger;
 
+import java.util.*;
 
-public class InterDimensionalInterfaceBlockEntity extends PatternProviderBlockEntity {
+
+public class InterDimensionalInterfaceBlockEntity extends AENetworkBlockEntity implements ICraftingProvider, IGridTickable, ICraftingSimulationRequester, IActionSource {
     private static final Logger LOGGER = LogUtils.getLogger();
+    protected String hostUUID;
+    protected NetworkPatternList networkPatternList;
+    protected List<IPatternDetails> newVirtualPatterns = new ArrayList<>();
+    protected List<IPatternDetails> oldVirtualPatterns = new ArrayList<>();
 
     public InterDimensionalInterfaceBlockEntity(BlockPos pos, BlockState blockState) {
         super(BlockEntityTypeInit.INTER_DIMENSIONAL_INTERFACE_ENTITY_TYPE.get(), pos, blockState);
+
+        this.getMainNode()
+                .addService(ICraftingProvider.class, this)
+                .addService(IGridTickable.class, this)
+                .setFlags(GridFlags.REQUIRE_CHANNEL)
+                .setVisualRepresentation(AEItemKey.of(ItemInit.INTER_DIMENSIONAL_INTERFACE_BLOCK.get()))
+                .setIdlePowerUsage(5000);
+
+        hostUUID = UUID.randomUUID().toString();
+        networkPatternList = new NetworkPatternList(this.hostUUID);
+    }
+
+    private void doWork(int ticksSinceLastCall) {
+
+        List<NetworkPattern> localNetworkPatterns = new ArrayList<>();
+        this.getMainNode().getGrid().getMachines(PatternProviderBlockEntity.class)
+                        .forEach(patternProviderBlockEntity -> patternProviderBlockEntity.getLogic().getAvailablePatterns()
+                                .forEach(pattern -> {
+                                    localNetworkPatterns.add(new NetworkPattern(this.hostUUID, pattern, patternProviderBlockEntity));
+                                }));
+        localNetworkPatterns.removeAll(networkPatternList.getRemoteNetworkPatterns());
+
+        localNetworkPatterns.forEach(localNetworkPattern -> {
+            if(!networkPatternList.instance().contains(localNetworkPattern)) {
+                networkPatternList.add(localNetworkPattern);
+                LOGGER.info(hostUUID + " | Added pattern to network! " + localNetworkPattern);
+            }
+        });
+
+        networkPatternList.getLocalNetworkPatterns().forEach(localNetworkPattern -> {
+            if(!localNetworkPatterns.contains(localNetworkPattern)) {
+                networkPatternList.remove(localNetworkPattern);
+                LOGGER.info(hostUUID + " | Removed pattern from network! " + localNetworkPattern);
+            }
+        });
+
+        newVirtualPatterns = networkPatternList.getRemotePatterns();
+        if(newVirtualPatterns != oldVirtualPatterns) {
+            oldVirtualPatterns = newVirtualPatterns;
+            try {
+//                this.getMainNode().getGrid().getService(ICraftingService.class).refreshNodeCraftingProvider(this.getGridNode());
+                ICraftingProvider.requestUpdate(this.getMainNode());
+            } catch (Exception e) {
+                LOGGER.error(hostUUID + " | Failed to update patterns!");
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @Override
+    public List<IPatternDetails> getAvailablePatterns() {
+        return newVirtualPatterns;
+    }
+
+    @Override
+    public boolean pushPattern(IPatternDetails patternDetails, KeyCounter[] inputHolder) {
+        NetworkPattern networkPattern = networkPatternList.getByPattern(patternDetails);
+        LOGGER.info(hostUUID + " | Pushing pattern! " + networkPattern);
+
+
+        this.getMainNode().getGrid().getCraftingService().beginCraftingCalculation(this.getLevel(), this, patternDetails.getPrimaryOutput().what(),   patternDetails.getPrimaryOutput().amount(),CalculationStrategy.CRAFT_LESS );
+        return networkPattern.pushPattern(inputHolder);
     }
 
     @Override
-    protected PatternProviderLogic createLogic() {
-        return new InterDimensionalInterfacePatternProvider(this.getMainNode(), this);
+    public boolean isBusy() {
+        return false;
     }
 
     @Override
-    public void onReady() {
-        super.onReady();
+    public TickingRequest getTickingRequest(IGridNode node) {
+        return new TickingRequest(TickRates.Charger, false, false);
+    }
 
-//        if(this.getMainNode().getGrid().getMachines(InterDimensionalInterfaceBlockEntity.class).size() >= 1) {
-//            this.getBlockState().getBlock().des
-//        }
-//
-//        this.getMainNode().getGrid().getMachines(PatternProviderBlockEntity.class)
-//                .forEach(patternProviderBlockEntity -> {
-//                    patternProviderBlockEntity.get
-//                });
+    @Override
+    public TickRateModulation tickingRequest(IGridNode node, int ticksSinceLastCall) {
+        doWork(ticksSinceLastCall);
+        return TickRateModulation.FASTER;
+    }
 
+    @Override
+    public void loadTag(CompoundTag data) {
+        super.loadTag(data);
+        data.putString("hostUUID", this.hostUUID);
+    }
 
+    @Override
+    public void saveAdditional(CompoundTag data) {
+        super.saveAdditional(data);
+        // TODO ADD READING OF "hostUUID" data from nbt
+    }
+
+
+    @Nullable
+    @Override
+    public IActionSource getActionSource() {
+        return this;
+    }
+
+    @Override
+    public Optional<Player> player() {
+        return Optional.empty();
     }
 
     @Override
-    public AEItemKey getTerminalIcon() {
-        return AEItemKey.of(ItemInit.INTER_DIMENSIONAL_INTERFACE_BLOCK.get());
+    public Optional<IActionHost> machine() {
+        return Optional.of(this);
     }
 
     @Override
-    public ItemStack getMainMenuIcon() {
-        return new ItemStack(ItemInit.INTER_DIMENSIONAL_INTERFACE_BLOCK.get());
+    public <T> Optional<T> context(Class<T> key) {
+        return Optional.empty();
     }
 }

src/main/java/net/nussi/dedicated_applied_energistics/providers/InterDimensionalInterfacePatternProvider.java

@@ -1,22 +1,28 @@
 package net.nussi.dedicated_applied_energistics.providers;
 
 import appeng.api.crafting.IPatternDetails;
+import appeng.api.crafting.PatternDetailsHelper;
 import appeng.api.inventories.InternalInventory;
 import appeng.api.networking.IManagedGridNode;
+import appeng.api.networking.crafting.ICraftingProvider;
 import appeng.api.stacks.KeyCounter;
 import appeng.helpers.iface.PatternProviderLogic;
 import appeng.helpers.iface.PatternProviderLogicHost;
 import appeng.util.inv.AppEngInternalInventory;
 import com.mojang.logging.LogUtils;
 import org.slf4j.Logger;
 
+import java.util.ArrayList;
 import java.util.List;
 
 public class InterDimensionalInterfacePatternProvider extends PatternProviderLogic {
     private static final Logger LOGGER = LogUtils.getLogger();
+    IManagedGridNode mainNode;
+    List<IPatternDetails> patterns = new ArrayList<>();
 
     public InterDimensionalInterfacePatternProvider(IManagedGridNode mainNode, PatternProviderLogicHost host) {
         super(mainNode, host);
+        this.mainNode = mainNode;
     }
 
     @Override
@@ -27,13 +33,18 @@ public InternalInventory getPatternInv() {
 
     @Override
     public List<IPatternDetails> getAvailablePatterns() {
-        return super.getAvailablePatterns();
+        return patterns;
     }
 
     @Override
     public boolean pushPattern(IPatternDetails patternDetails, KeyCounter[] inputHolder) {
         return super.pushPattern(patternDetails, inputHolder);
     }
 
+    @Override
+    public void updatePatterns() {
+        patterns.clear();
 
+        ICraftingProvider.requestUpdate(mainNode);
+    }
 }

src/main/java/net/nussi/dedicated_applied_energistics/providers/NetworkPattern.java

@@ -1,11 +1,48 @@
 package net.nussi.dedicated_applied_energistics.providers;
 
 import appeng.api.crafting.IPatternDetails;
+import appeng.api.stacks.KeyCounter;
+import appeng.blockentity.crafting.PatternProviderBlockEntity;
+
+import java.util.UUID;
 
 public class NetworkPattern {
-    private String hostUUID;
+    public String patternUUID;
+    public String hostUUID;
+    public IPatternDetails pattern;
+    public PatternProviderBlockEntity patternProvider;
 
-    public NetworkPattern(String hostUUID, IPatternDetails pattern) {
+    public NetworkPattern(String hostUUID, IPatternDetails pattern, PatternProviderBlockEntity patternProvider) {
         this.hostUUID = hostUUID;
+        this.pattern = pattern;
+        this.patternProvider = patternProvider;
+        this.patternUUID = patternToUUID(pattern);
+    }
+
+    public boolean pushPattern(KeyCounter[] inputHolder) {
+
+        return patternProvider.getLogic().pushPattern(pattern, inputHolder);
+    }
+
+        @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof NetworkPattern networkPattern) {
+            return networkPattern.patternUUID.equals(this.patternUUID);
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return "NetworkPattern{" +
+                "patternUUID='" + patternUUID + '\'' +
+                ", hostUUID='" + hostUUID + '\'' +
+                ", pattern=" + pattern +
+                ", patternProvider=" + patternProvider +
+                '}';
+    }
+
+    public static String patternToUUID(IPatternDetails pattern) {
+        return String.valueOf(pattern.hashCode());
     }
 }

src/main/java/net/nussi/dedicated_applied_energistics/providers/NetworkPatternList.java

@@ -0,0 +1,52 @@
+package net.nussi.dedicated_applied_energistics.providers;
+
+import appeng.api.crafting.IPatternDetails;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.Vector;
+
+public class NetworkPatternList {
+    private static final Vector<NetworkPattern> patterns = new Vector<>();
+    private String hostUUID;
+
+    public NetworkPatternList(String hostUUID) {
+        this.hostUUID = hostUUID;
+    }
+
+    public List<NetworkPattern> getLocalNetworkPatterns() {
+        return patterns.stream().filter(networkPattern -> networkPattern.hostUUID.equals(this.hostUUID)).toList();
+    }
+
+    public List<NetworkPattern> getRemoteNetworkPatterns() {
+        return patterns.stream().filter(networkPattern -> !networkPattern.hostUUID.equals(this.hostUUID)).toList();
+    }
+
+    public List<IPatternDetails> getLocalPatterns() {
+        return getLocalNetworkPatterns().stream().map(networkPattern -> networkPattern.pattern).toList();
+    }
+
+    public List<IPatternDetails> getRemotePatterns() {
+        return getRemoteNetworkPatterns().stream().map(networkPattern -> networkPattern.pattern).toList();
+    }
+
+    public Vector<NetworkPattern> instance() {
+        return patterns;
+    }
+
+    public void add(NetworkPattern networkPattern) {
+        patterns.add(networkPattern);
+    }
+
+    public void remove(NetworkPattern networkPattern) {
+        patterns.remove(networkPattern);
+    }
+
+    public NetworkPattern getByPattern(IPatternDetails pattern) {
+        for(NetworkPattern networkPattern : patterns) {
+            if(networkPattern.patternUUID.equals(NetworkPattern.patternToUUID(pattern))) return networkPattern;
+        }
+        return null;
+    }
+
+}