Use a PipeNetWalker instead of manually iterating over a pipenet

Author: htmlcsjs

src/main/java/gregtech/common/ToolEventHandlers.java

@@ -305,8 +305,7 @@ private static boolean shouldRenderGridOverlays(@NotNull IBlockState state, @Nul
                                                     ItemStack mainHand, ItemStack offHand, boolean isSneaking) {
         if (state.getBlock() instanceof BlockPipe<?, ?, ?>pipe) {
             if (isSneaking &&
-                    (mainHand.isEmpty() || mainHand.getItem().getClass() == Item.getItemFromBlock(pipe).getClass() ||
-                            GTUtility.isSprayCan(mainHand) || GTUtility.isSprayCan(offHand))) {
+                    (mainHand.isEmpty() || mainHand.getItem().getClass() == Item.getItemFromBlock(pipe).getClass())) {
                 return true;
             } else {
                 Set<String> mainToolClasses = mainHand.getItem().getToolClasses(mainHand);

src/main/java/gregtech/common/items/behaviors/ColorSprayBehavior.java

@@ -7,6 +7,7 @@
 import gregtech.api.pipenet.tile.IPipeTile;
 import gregtech.api.util.GradientUtil;
 import gregtech.api.util.Mods;
+import gregtech.common.pipelike.PipeCollectorWalker;
 import gregtech.core.sound.GTSoundEvents;
 
 import net.minecraft.block.Block;
@@ -134,38 +135,27 @@ private boolean traversePipes(EntityPlayer player, World world, EnumHand hand, B
                                   EnumFacing facing) {
         startPos = startPos.offset(facing);
         TileEntity connectedTe = world.getTileEntity(startPos);
-        int count = 0;
         boolean painted = false;
         ItemStack heldItem = player.getHeldItem(hand);
-        while (connectedTe instanceof IPipeTile<?, ?>connectedPipe && count < MAX_PIPE_TRAVERSAL_LENGTH) {
-            if (connectedPipe.getPaintingColor() != (this.color == null ? -1 : this.color.colorValue)) {
-                connectedPipe.setPaintingColor(this.color == null ? -1 : this.color.colorValue);
-                connectedPipe.scheduleRenderUpdate();
-                if (getUsesLeft(heldItem) == 1) {
-                    useItemDurability(player, hand, heldItem, empty.copy());
-                    return true;
-                }
-                // Off by one durability as the final use is handled by onItemUse, along with the use animation
-                if (painted) {
-                    useItemDurability(player, hand, heldItem, empty.copy());
-                }
-                painted = true;
-            }
-            if (connectedPipe.getNumConnections() == 2) {
-                int connections = connectedPipe.getConnections();
-                connections &= ~(1 << facing.getOpposite().getIndex());
-                for (EnumFacing other : EnumFacing.VALUES) {
-                    if ((connections & (1 << other.getIndex())) != 0) {
-                        facing = other;
-                        startPos = startPos.offset(facing);
-                        connectedTe = world.getTileEntity(startPos);
-                        count++;
-                        break;
+        if (connectedTe instanceof IPipeTile<?, ?>startPipe) {
+            List<IPipeTile<?, ?>> pipes = PipeCollectorWalker.collectPipeNet(world, startPos, startPipe,
+                    Math.min(MAX_PIPE_TRAVERSAL_LENGTH, getUsesLeft(heldItem)));
+            for (IPipeTile<?, ?> pipe : pipes) {
+                if (pipe.getPaintingColor() != (this.color == null ? -1 : this.color.colorValue)) {
+                    pipe.setPaintingColor(this.color == null ? -1 : this.color.colorValue);
+                    pipe.scheduleRenderUpdate();
+                    if (getUsesLeft(heldItem) == 1) {
+                        useItemDurability(player, hand, heldItem, empty.copy());
+                        return true;
+                    }
+                    // Off by one durability as the final use is handled by onItemUse, along with the use animation
+                    if (painted) {
+                        useItemDurability(player, hand, heldItem, empty.copy());
                     }
+                    painted = true;
                 }
-            } else {
-                break;
             }
+
         }
         return painted;
     }

src/main/java/gregtech/common/pipelike/PipeCollectorWalker.java

@@ -0,0 +1,69 @@
+package gregtech.common.pipelike;
+
+import gregtech.api.pipenet.PipeNetWalker;
+import gregtech.api.pipenet.tile.IPipeTile;
+
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class PipeCollectorWalker<T extends IPipeTile<?, ?>> extends PipeNetWalker<T> {
+
+    @NotNull
+    @SuppressWarnings("unchecked")
+    public static List<IPipeTile<?, ?>> collectPipeNet(World world, BlockPos sourcePipe, IPipeTile<?, ?> pipe,
+                                                       int limit) {
+        PipeCollectorWalker<? extends IPipeTile<?, ?>> walker = (PipeCollectorWalker<? extends IPipeTile<?, ?>>) new PipeCollectorWalker<>(
+                world, sourcePipe, 0, pipe.getClass());
+        walker.traversePipeNet(limit);
+        return walker.isFailed() ? Collections.EMPTY_LIST : Collections.unmodifiableList(walker.pipes);
+    }
+
+    public static List<IPipeTile<?, ?>> collectPipeNet(World world, BlockPos sourcePipe, IPipeTile<?, ?> pipe) {
+        // Default limit for a pipenet walker
+        return collectPipeNet(world, sourcePipe, pipe, 32768);
+    }
+
+    // I love type erasure
+    private final Class<T> basePipeClass;
+    private List<T> pipes = new ArrayList<>();
+    private BlockPos sourcePipe;
+
+    protected PipeCollectorWalker(World world, BlockPos sourcePipe, int walkedBlocks, Class<T> basePipeClass) {
+        super(world, sourcePipe, walkedBlocks);
+        this.sourcePipe = sourcePipe;
+        this.basePipeClass = basePipeClass;
+    }
+
+    @Override
+    protected PipeNetWalker<T> createSubWalker(World world, EnumFacing facingToNextPos, BlockPos nextPos,
+                                               int walkedBlocks) {
+        PipeCollectorWalker<T> walker = new PipeCollectorWalker<>(world, nextPos, walkedBlocks, this.basePipeClass);
+        walker.pipes = pipes;
+        walker.sourcePipe = sourcePipe;
+        return walker;
+    }
+
+    @Override
+    protected void checkPipe(T pipeTile, BlockPos pos) {
+        this.pipes.add(pipeTile);
+    }
+
+    @Override
+    protected void checkNeighbour(T pipeTile, BlockPos pipePos, EnumFacing faceToNeighbour,
+                                  @Nullable TileEntity neighbourTile) {
+    }
+
+    @Override
+    protected Class<T> getBasePipeClass() {
+        return basePipeClass;
+    }
+}

src/main/resources/assets/gregtech/lang/en_us.lang

@@ -4701,7 +4701,7 @@ behaviour.paintspray.red.tooltip=Can paint things in Red
 behaviour.paintspray.black.tooltip=Can paint things in Black
 behaviour.paintspray.uses=Remaining Uses: %,d
 behaviour.paintspray.offhand=Hold in offhand to color while placing blocks
-behaviour.paintspray.crouch=Crouch to spray a line of pipes
+behaviour.paintspray.crouch=Crouch to spray a network of pipes
 behaviour.prospecting=Usable for Prospecting
 
 # Multiblock machine controllers