Add a couple helper methods to Path to make it a little clearer what is going on, and remove flowing stack targets when there are no more stacks being sent to a location

Author: pupnewfster

src/main/java/mekanism/common/capabilities/item/CursedTransporterItemHandler.java

@@ -9,7 +9,6 @@
 import java.util.function.LongSupplier;
 import mekanism.common.content.network.transmitter.LogisticalTransporterBase;
 import mekanism.common.content.transporter.TransporterStack;
-import mekanism.common.content.transporter.TransporterStack.Path;
 import mekanism.common.lib.inventory.TransitRequest;
 import mekanism.common.lib.inventory.TransitRequest.TransitResponse;
 import net.minecraft.core.BlockPos;
@@ -97,7 +96,7 @@ public ItemStack insertItem(int slot, @NotNull ItemStack itemStack, boolean simu
             //Just setting the transporter stack's stack is equivalent to LogisticalTransporterBase#updateTransit when simulating
             // as we already know the response is not empty
             stack.itemStack = response.getStack();
-            if (stack.getPathType() != Path.NONE) {
+            if (stack.getPathType().hasTarget()) {
                 //If the stack actually has a path add that simulated insert to a list of locally simulated flowing stacks so that
                 // if the mod simulates against the next slot as well we can give a more accurate result
                 simulatedFlowingStacks.computeIfAbsent(GlobalPos.of(transporter.getLevel().dimension(), stack.getDest()), k -> new ObjectOpenHashSet<>()).add(stack);

src/main/java/mekanism/common/content/network/transmitter/LogisticalTransporterBase.java

@@ -148,7 +148,7 @@ public void onUpdateServer() {
                 for (Int2ObjectMap.Entry<TransporterStack> entry : transit.int2ObjectEntrySet()) {
                     int stackId = entry.getIntKey();
                     TransporterStack stack = entry.getValue();
-                    if (!stack.initiatedPath) {
+                    if (!stack.initiatedPath) {//Initiate any paths and remove things that can't go places
                         if (stack.itemStack.isEmpty() || !recalculate(stackId, stack, null)) {
                             deletes.add(stackId);
                             continue;
@@ -168,18 +168,20 @@ public void onUpdateServer() {
                             BlockPos next = stack.getPath().get(currentIndex - 1);
                             if (next != null) {
                                 if (!stack.isFinal(this)) {
+                                    //If this is not the final transporter try transferring it to the next one
                                     LogisticalTransporterBase transmitter = network.getTransmitter(next);
                                     if (stack.canInsertToTransporter(transmitter, stack.getSide(this), this)) {
                                         transmitter.entityEntering(stack, stack.progress % 100);
                                         deletes.add(stackId);
                                         continue;
                                     }
                                     prevSet = next;
-                                } else if (stack.getPathType() != Path.NONE) {
+                                } else if (stack.getPathType().hasTarget()) {
+                                    //Otherwise, try to insert it into the destination inventory
                                     //Get the handler we are trying to insert into from the network's acceptor cache
                                     IItemHandler acceptor = network.getCachedAcceptor(next, stack.getSide(this).getOpposite());
                                     TransitResponse response = TransitRequest.simple(stack.itemStack).addToInventory(getLevel(), next, acceptor, 0,
-                                          stack.getPathType() == Path.HOME);
+                                          stack.getPathType().isHome());
                                     if (!response.isEmpty()) {
                                         //We were able to add at least part of the stack to the inventory
                                         ItemStack rejected = response.getRejected();
@@ -191,7 +193,7 @@ public void onUpdateServer() {
                                             continue;
                                         }
                                         //Some portion of the stack got rejected; save the remainder and
-                                        // let the recalculate below sort out what to do next
+                                        // recalculate below to sort out what to do next
                                         stack.itemStack = rejected;
                                     }//else the entire stack got rejected (Note: we don't need to update the stack to point to itself)
                                     prevSet = next;
@@ -209,17 +211,17 @@ public void onUpdateServer() {
                         boolean tryRecalculate;
                         if (stack.isFinal(this)) {
                             Path pathType = stack.getPathType();
-                            if (pathType == Path.DEST || pathType == Path.HOME) {
+                            if (pathType.hasTarget()) {
                                 Direction side = stack.getSide(this);
                                 ConnectionType connectionType = getConnectionType(side);
                                 tryRecalculate = !connectionType.canSendTo() ||
-                                                 !TransporterUtils.canInsert(getLevel(), stack.getDest(), stack.color, stack.itemStack, side, pathType == Path.HOME);
+                                                 !TransporterUtils.canInsert(getLevel(), stack.getDest(), stack.color, stack.itemStack, side, pathType.isHome());
                             } else {
-                                tryRecalculate = pathType == Path.NONE;
+                                tryRecalculate = pathType.isHome();
                             }
                         } else {
                             LogisticalTransporterBase nextTransmitter = network.getTransmitter(stack.getNext(this));
-                            if (nextTransmitter == null && stack.getPathType() == Path.NONE && stack.getPath().size() == 2) {
+                            if (nextTransmitter == null && stack.getPathType().noTarget() && stack.getPath().size() == 2) {
                                 //If there is no next transmitter, and it was an idle path, assume that we are idling
                                 // in a single length transmitter, in which case we only recalculate it at 50 if it won't
                                 // be able to go into that connection type
@@ -363,7 +365,7 @@ public void addStack(int id, TransporterStack s) {
 
     private boolean recalculate(int stackId, TransporterStack stack, BlockPos from) {
         //TODO: Why do we skip recalculating the path if it is idle. Is it possible for idle paths to eventually stop being idle or are they just idle forever??
-        boolean noPath = stack.getPathType() == Path.NONE || stack.recalculatePath(TransitRequest.simple(stack.itemStack), this, 0).isEmpty();
+        boolean noPath = stack.getPathType().noTarget() || stack.recalculatePath(TransitRequest.simple(stack.itemStack), this, 0).isEmpty();
         if (noPath && !stack.calculateIdle(this)) {
             TransporterUtils.drop(this, stack);
             return false;

src/main/java/mekanism/common/content/transporter/TransporterManager.java

@@ -1,11 +1,10 @@
 package mekanism.common.content.transporter;
 
 import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
-import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
 import java.util.Arrays;
+import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
-import mekanism.common.content.transporter.TransporterStack.Path;
 import mekanism.common.lib.inventory.TransitRequest;
 import mekanism.common.lib.inventory.TransitRequest.ItemData;
 import mekanism.common.lib.inventory.TransitRequest.TransitResponse;
@@ -29,12 +28,16 @@ public static void reset() {
     }
 
     public static void add(Level world, TransporterStack stack) {
-        flowingStacks.computeIfAbsent(GlobalPos.of(world.dimension(), stack.getDest()), k -> new ObjectOpenHashSet<>()).add(stack);
+        flowingStacks.computeIfAbsent(GlobalPos.of(world.dimension(), stack.getDest()), k -> new HashSet<>()).add(stack);
     }
 
     public static void remove(Level world, TransporterStack stack) {
-        if (stack.hasPath() && stack.getPathType() != Path.NONE) {
-            flowingStacks.get(GlobalPos.of(world.dimension(), stack.getDest())).remove(stack);
+        if (stack.hasPath() && stack.getPathType().hasTarget()) {
+            GlobalPos pos = GlobalPos.of(world.dimension(), stack.getDest());
+            Set<TransporterStack> transporterStacks = flowingStacks.get(pos);
+            if (transporterStacks.remove(stack) && transporterStacks.isEmpty()) {
+                flowingStacks.remove(pos);
+            }
         }
     }
 
@@ -205,7 +208,7 @@ private static boolean predictFlowing(GlobalPos position, Direction side, IItemH
         Set<TransporterStack> transporterStacks = flowingStacks.get(position);
         if (transporterStacks != null) {
             for (TransporterStack stack : transporterStacks) {
-                if (stack != null && stack.getPathType() != Path.NONE) {
+                if (stack != null && stack.getPathType().hasTarget()) {
                     //We start by simulating inserting the stack into the handler, regardless of if we
                     // are interacting with the same side of the target as the stack's path is taking.
                     // This is so that in cases where the item handler is shared (chests) or some of

src/main/java/mekanism/common/content/transporter/TransporterStack.java

@@ -45,6 +45,7 @@ public class TransporterStack {
     public BlockPos homeLocation;
     private BlockPos clientNext;
     private BlockPos clientPrev;
+    @Nullable
     private Path pathType;
     private List<BlockPos> pathToTarget = new ArrayList<>();
 
@@ -73,7 +74,7 @@ public void write(FriendlyByteBuf buf, BlockPos pos) {
         buf.writeVarInt(TransporterUtils.getColorIndex(color));
         buf.writeVarInt(progress);
         buf.writeBlockPos(originalLocation);
-        buf.writeEnum(pathType);
+        buf.writeEnum(getPathType());
         buf.writeNullable(getNext(pos), FriendlyByteBuf::writeBlockPos);
         buf.writeBlockPos(getPrev(pos));
         buf.writeItem(itemStack);
@@ -98,7 +99,7 @@ public void writeToUpdateTag(LogisticalTransporterBase transporter, CompoundTag
         }
         updateTag.putInt(NBTConstants.PROGRESS, progress);
         updateTag.put(NBTConstants.ORIGINAL_LOCATION, NbtUtils.writeBlockPos(originalLocation));
-        NBTUtils.writeEnum(updateTag, NBTConstants.PATH_TYPE, pathType);
+        NBTUtils.writeEnum(updateTag, NBTConstants.PATH_TYPE, getPathType());
         BlockPos next = getNext(transporter);
         if (next != null) {
             updateTag.put(NBTConstants.CLIENT_NEXT, NbtUtils.writeBlockPos(next));
@@ -131,7 +132,9 @@ public void write(CompoundTag nbtTags) {
         if (homeLocation != null) {
             nbtTags.put(NBTConstants.HOME_LOCATION, NbtUtils.writeBlockPos(homeLocation));
         }
-        NBTUtils.writeEnum(nbtTags, NBTConstants.PATH_TYPE, pathType);
+        if (pathType != null) {
+            NBTUtils.writeEnum(nbtTags, NBTConstants.PATH_TYPE, pathType);
+        }
         itemStack.save(nbtTags);
     }
 
@@ -145,30 +148,30 @@ public void read(CompoundTag nbtTags) {
         itemStack = ItemStack.of(nbtTags);
     }
 
-    private void setPath(Level world, List<BlockPos> path, Path type, boolean updateFlowing) {
+    private void setPath(Level world, @NotNull List<BlockPos> path, @NotNull Path type, boolean updateFlowing) {
         //Make sure old path isn't null
-        if (updateFlowing && pathType != Path.NONE) {
+        if (updateFlowing && (pathType == null || pathType.hasTarget())) {
             //Only update the actual flowing stacks if we want to modify more than our current stack
             TransporterManager.remove(world, this);
         }
         pathToTarget = path;
         pathType = type;
-        if (updateFlowing && pathType != Path.NONE) {
+        if (updateFlowing && pathType.hasTarget()) {
             //Only update the actual flowing stacks if we want to modify more than our current stack
             TransporterManager.add(world, this);
         }
     }
 
     public boolean hasPath() {
-        return pathToTarget != null && pathToTarget.size() >= 2;
+        return pathToTarget.size() >= 2;
     }
 
     public List<BlockPos> getPath() {
         return pathToTarget;
     }
 
     public Path getPathType() {
-        return pathType;
+        return pathType == null ? Path.NONE : pathType;
     }
 
     public TransitResponse recalculatePath(TransitRequest request, LogisticalTransporterBase transporter, int min) {
@@ -220,7 +223,7 @@ public boolean calculateIdle(LogisticalTransporterBase transporter) {
         if (newPath == null) {
             return false;
         }
-        if (newPath.type() == Path.HOME) {
+        if (newPath.type().isHome()) {
             idleDir = null;
         }
         setPath(transporter.getLevel(), newPath.path(), newPath.type(), true);
@@ -230,7 +233,7 @@ public boolean calculateIdle(LogisticalTransporterBase transporter) {
     }
 
     public boolean isFinal(LogisticalTransporterBase transporter) {
-        return pathToTarget.indexOf(transporter.getBlockPos()) == (pathType == Path.NONE ? 0 : 1);
+        return pathToTarget.indexOf(transporter.getBlockPos()) == (getPathType().hasTarget() ? 1 : 0);
     }
 
     public BlockPos getNext(LogisticalTransporterBase transporter) {
@@ -317,5 +320,17 @@ public enum Path {
         public static Path byIndexStatic(int index) {
             return MathUtils.getByIndexMod(PATHS, index);
         }
+
+        public boolean hasTarget() {
+            return this != NONE;
+        }
+
+        public boolean noTarget() {
+            return this == NONE;
+        }
+
+        public boolean isHome() {
+            return this == HOME;
+        }
     }
 }