From be04d9992ca153f3df8dd622eb13b60d58f1e7a6 Mon Sep 17 00:00:00 2001 From: DaNussi Date: Tue, 31 Oct 2023 03:03:49 +0100 Subject: [PATCH] It's 3am --- .../InterDimensionalInterfaceBlockEntity.java | 143 +++++++++++++++--- ...erDimensionalInterfacePatternProvider.java | 13 +- .../providers/NetworkPattern.java | 41 ++++- .../providers/NetworkPatternList.java | 52 +++++++ 4 files changed, 226 insertions(+), 23 deletions(-) create mode 100644 src/main/java/net/nussi/dedicated_applied_energistics/providers/NetworkPatternList.java diff --git a/src/main/java/net/nussi/dedicated_applied_energistics/blockentities/InterDimensionalInterfaceBlockEntity.java b/src/main/java/net/nussi/dedicated_applied_energistics/blockentities/InterDimensionalInterfaceBlockEntity.java index 43943ad..20b55c2 100644 --- a/src/main/java/net/nussi/dedicated_applied_energistics/blockentities/InterDimensionalInterfaceBlockEntity.java +++ b/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 newVirtualPatterns = new ArrayList<>(); + protected List 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 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 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() { + return Optional.empty(); } @Override - public AEItemKey getTerminalIcon() { - return AEItemKey.of(ItemInit.INTER_DIMENSIONAL_INTERFACE_BLOCK.get()); + public Optional machine() { + return Optional.of(this); } @Override - public ItemStack getMainMenuIcon() { - return new ItemStack(ItemInit.INTER_DIMENSIONAL_INTERFACE_BLOCK.get()); + public Optional context(Class key) { + return Optional.empty(); } } diff --git a/src/main/java/net/nussi/dedicated_applied_energistics/providers/InterDimensionalInterfacePatternProvider.java b/src/main/java/net/nussi/dedicated_applied_energistics/providers/InterDimensionalInterfacePatternProvider.java index 09c5643..d12e403 100644 --- a/src/main/java/net/nussi/dedicated_applied_energistics/providers/InterDimensionalInterfacePatternProvider.java +++ b/src/main/java/net/nussi/dedicated_applied_energistics/providers/InterDimensionalInterfacePatternProvider.java @@ -1,8 +1,10 @@ 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; @@ -10,13 +12,17 @@ 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 patterns = new ArrayList<>(); public InterDimensionalInterfacePatternProvider(IManagedGridNode mainNode, PatternProviderLogicHost host) { super(mainNode, host); + this.mainNode = mainNode; } @Override @@ -27,7 +33,7 @@ public InternalInventory getPatternInv() { @Override public List getAvailablePatterns() { - return super.getAvailablePatterns(); + return patterns; } @Override @@ -35,5 +41,10 @@ public boolean pushPattern(IPatternDetails patternDetails, KeyCounter[] inputHol return super.pushPattern(patternDetails, inputHolder); } + @Override + public void updatePatterns() { + patterns.clear(); + ICraftingProvider.requestUpdate(mainNode); + } } diff --git a/src/main/java/net/nussi/dedicated_applied_energistics/providers/NetworkPattern.java b/src/main/java/net/nussi/dedicated_applied_energistics/providers/NetworkPattern.java index ef39062..4eb2791 100644 --- a/src/main/java/net/nussi/dedicated_applied_energistics/providers/NetworkPattern.java +++ b/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()); } } diff --git a/src/main/java/net/nussi/dedicated_applied_energistics/providers/NetworkPatternList.java b/src/main/java/net/nussi/dedicated_applied_energistics/providers/NetworkPatternList.java new file mode 100644 index 0000000..8a24e2e --- /dev/null +++ b/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 patterns = new Vector<>(); + private String hostUUID; + + public NetworkPatternList(String hostUUID) { + this.hostUUID = hostUUID; + } + + public List getLocalNetworkPatterns() { + return patterns.stream().filter(networkPattern -> networkPattern.hostUUID.equals(this.hostUUID)).toList(); + } + + public List getRemoteNetworkPatterns() { + return patterns.stream().filter(networkPattern -> !networkPattern.hostUUID.equals(this.hostUUID)).toList(); + } + + public List getLocalPatterns() { + return getLocalNetworkPatterns().stream().map(networkPattern -> networkPattern.pattern).toList(); + } + + public List getRemotePatterns() { + return getRemoteNetworkPatterns().stream().map(networkPattern -> networkPattern.pattern).toList(); + } + + public Vector 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; + } + +}