22182377337

Committed 19 Feb 2026 12:46PM UTC coverage: 44.49% (-1.7%) from 46.183%

Build # 22182377337

Build Type

push

github

Committed by

rubensworks

Commit Message

Fix performance workflow failing

Run Details

2663 of 8850 branches covered (30.09%)

Branch coverage included in aggregate %.

12028 of 24171 relevant lines covered (49.76%)

2.36 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

3.93

/src/main/java/org/cyclops/integrateddynamics/command/CommandGenerateNetwork.java

package org.cyclops.integrateddynamics.command;

import com.mojang.brigadier.Command;
import com.mojang.brigadier.arguments.IntegerArgumentType;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import com.mojang.brigadier.context.CommandContext;
import com.mojang.brigadier.exceptions.CommandSyntaxException;
import net.minecraft.ChatFormatting;
import net.minecraft.commands.CommandSourceStack;
import net.minecraft.commands.Commands;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.network.chat.Component;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.world.item.ItemStack;
import org.cyclops.cyclopscore.command.argument.ArgumentTypeEnum;
import org.cyclops.integrateddynamics.RegistryEntries;
import org.cyclops.integrateddynamics.api.part.IPartType;
import org.cyclops.integrateddynamics.api.part.PartPos;
import org.cyclops.integrateddynamics.block.BlockCable;
import org.cyclops.integrateddynamics.blockentity.BlockEntityVariablestore;
import org.cyclops.integrateddynamics.core.evaluate.operator.Operators;
import org.cyclops.integrateddynamics.core.evaluate.variable.ValueTypeInteger;
import org.cyclops.integrateddynamics.core.evaluate.variable.ValueTypes;
import org.cyclops.integrateddynamics.core.helper.CableHelpers;
import org.cyclops.integrateddynamics.core.helper.NetworkHelpers;
import org.cyclops.integrateddynamics.core.helper.PartHelpers;
import org.cyclops.integrateddynamics.core.part.PartTypeRegistry;
import org.cyclops.integrateddynamics.core.part.PartTypes;
import org.cyclops.integrateddynamics.gametest.GameTestHelpersIntegratedDynamics;
import org.cyclops.integrateddynamics.part.aspect.Aspects;
import org.cyclops.integrateddynamics.part.aspect.read.AspectReadBuilders;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * Command for generating networks with different presets.
 * @author rubensworks
 */
public class CommandGenerateNetwork implements Command<CommandSourceStack> {

    public static LiteralArgumentBuilder<CommandSourceStack> make() {
        LiteralArgumentBuilder<CommandSourceStack> builder = Commands.literal("generatenetwork")
                .requires((commandSource) -> commandSource.hasPermission(2));

        // Add the preset subcommand with optional size/radius argument
        builder.then(Commands.argument("preset", new ArgumentTypeEnum(NetworkPreset.class))
                .executes(new CommandGenerateNetworkExecutor(true, false))
                .then(Commands.argument("size", IntegerArgumentType.integer(1, 1000))
                        .executes(new CommandGenerateNetworkExecutor(true, true))));

        return builder;
    }

    @Override
    public int run(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
        context.getSource().sendFailure(Component.literal("Please specify a preset: empty, idle, redstoneioclock, or clear")
                .withStyle(ChatFormatting.RED));
        return 0;
    }

    public enum NetworkPreset {
        EMPTY,
        IDLE,
        REDSTONEIOCLOCK,
        REDSTONEIOCLOCKVARIABLES,
        CLEAR
    }

    /**
     * Executor for the generatenetwork command.
     */
    public static class CommandGenerateNetworkExecutor implements Command<CommandSourceStack> {
        private final boolean hasPreset;
        private final boolean hasSize;

        public CommandGenerateNetworkExecutor(boolean hasPreset, boolean hasSize) {
            this.hasPreset = hasPreset;
            this.hasSize = hasSize;
        }

        @Override
        public int run(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
            if (!hasPreset) {
                context.getSource().sendFailure(Component.literal("Please specify a preset: empty, idle, redstoneioclock, or clear")
                        .withStyle(ChatFormatting.RED));
                return 0;
            }

            NetworkPreset preset = ArgumentTypeEnum.getValue(context, "preset", NetworkPreset.class);
            ServerLevel level = context.getSource().getLevel();
            BlockPos playerPos = BlockPos.containing(context.getSource().getPosition());
            int size = hasSize ? IntegerArgumentType.getInteger(context, "size") : getDefaultSize(preset);

            switch (preset) {
                case EMPTY:
                    context.getSource().sendSuccess(
                            () -> Component.literal("Generating network preset: empty (size: " + size + "x" + size + "x" + size + ")")
                                    .withStyle(ChatFormatting.GREEN),
                            true);
                    NetworkGenerationHelper.generateEmptyNetwork(level, playerPos.above(2), size);
                    break;
                case IDLE:
                    context.getSource().sendSuccess(
                            () -> Component.literal("Generating network preset: idle (size: " + size + "x" + size + "x" + size + ")")
                                    .withStyle(ChatFormatting.GREEN),
                            true);
                    NetworkGenerationHelper.generateIdleNetwork(level, playerPos.above(2), size);
                    break;
                case REDSTONEIOCLOCK:
                    context.getSource().sendSuccess(
                            () -> Component.literal("Generating network preset: redstoneioclock (size: " + size + "x" + size + "x" + size + ")")
                                    .withStyle(ChatFormatting.GREEN),
                            true);
                    NetworkGenerationHelper.generateRedstoneNetwork(level, playerPos.above(2), size);
                    break;
                case REDSTONEIOCLOCKVARIABLES:
                    context.getSource().sendSuccess(
                            () -> Component.literal("Generating network preset: redstoneioclockvariables (size: " + size + "x" + size + "x" + size + ")")
                                    .withStyle(ChatFormatting.GREEN),
                            true);
                    NetworkGenerationHelper.generateRedstoneNetworkVariables(level, playerPos.above(2), size);
                    break;
                case CLEAR:
                    context.getSource().sendSuccess(
                            () -> Component.literal("Clearing cables within radius: " + size)
                                    .withStyle(ChatFormatting.GREEN),
                            true);
                    NetworkGenerationHelper.clearCables(level, playerPos, size);
                    break;
            }

            return 1;
        }

        /**
         * Get the default size/radius for the given preset.
         */
        private int getDefaultSize(NetworkPreset preset) {
            return preset == NetworkPreset.CLEAR ? 50 : 25;
        }
    }

    /**
     * Helper class for network generation logic, shared between command and game tests.
     */
    public static class NetworkGenerationHelper {
        /**
         * Generate a size x size x size cube of only logic cables.
         */
        public static void generateEmptyNetwork(ServerLevel level, BlockPos startPos, int size) {
            List<BlockPos> placedPositions = new ArrayList<>();

            BlockCable.SKIP_NETWORK_INIT = true;
            try {
                for (int x = 0; x < size; x++) {
                    for (int y = 0; y < size; y++) {
                        for (int z = 0; z < size; z++) {
                            BlockPos pos = startPos.offset(x, y, z);
                            level.setBlock(pos, RegistryEntries.BLOCK_CABLE.value().defaultBlockState(), 2);
                            placedPositions.add(pos);
                        }
                    }
                }
            } finally {
                BlockCable.SKIP_NETWORK_INIT = false;
            }

            for (BlockPos pos : placedPositions) {
                CableHelpers.updateConnectionsNeighbours(level, pos, CableHelpers.ALL_SIDES);
            }

            NetworkHelpers.initNetwork(level, startPos, null);
        }

        /**
         * Generate a size x size x size cube of logic cables where all cables on the outer sides
         * contain random parts facing outwards.
         */
        public static void generateIdleNetwork(ServerLevel level, BlockPos startPos, int size) {
            generateEmptyNetwork(level, startPos, size);

            Random random = new Random();
            List<BlockPos> updatePositions = new ArrayList<>();

            addPartsToFace(level, startPos, size, 0, size - 1, size - 1, size - 1, 0, size - 1, Direction.UP, random, updatePositions);
            addPartsToFace(level, startPos, size, 0, size - 1, 0, 0, 0, size - 1, Direction.DOWN, random, updatePositions);
            addPartsToFace(level, startPos, size, 0, size - 1, 0, size - 1, 0, 0, Direction.NORTH, random, updatePositions);
            addPartsToFace(level, startPos, size, 0, size - 1, 0, size - 1, size - 1, size - 1, Direction.SOUTH, random, updatePositions);
            addPartsToFace(level, startPos, size, 0, 0, 0, size - 1, 0, size - 1, Direction.WEST, random, updatePositions);
            addPartsToFace(level, startPos, size, size - 1, size - 1, 0, size - 1, 0, size - 1, Direction.EAST, random, updatePositions);

            for (BlockPos pos : updatePositions) {
                level.blockUpdated(pos, RegistryEntries.BLOCK_CABLE.value());
            }
        }

        /**
         * Place a single cable block at the given position.
         */
        public static void placeCable(ServerLevel level, BlockPos pos) {
            level.setBlock(pos, RegistryEntries.BLOCK_CABLE.value().defaultBlockState(), 2);
        }

        /**
         * Add a random part to the NORTH face of a cable at the given position.
         */
        public static void addPartToNorthFace(ServerLevel level, BlockPos pos) {
            List<IPartType> partTypes = new ArrayList<>(PartTypeRegistry.getInstance().getPartTypes());

            if (partTypes.isEmpty()) {
                return;
            }

            Random random = new Random();
            IPartType partType = partTypes.get(random.nextInt(partTypes.size()));
            ItemStack itemStack = new ItemStack(partType.getItem());
            PartHelpers.addPart(level, pos, Direction.NORTH, partType, itemStack);
        }

        /**
         * Clear all cable blocks within a radius of the given position.
         */
        public static void clearCables(ServerLevel level, BlockPos centerPos, int radius) {
            BlockCable.SKIP_NETWORK_INIT = true;

            try {
                for (int x = centerPos.getX() - radius; x <= centerPos.getX() + radius; x++) {
                    for (int y = centerPos.getY() - radius; y <= centerPos.getY() + radius; y++) {
                        for (int z = centerPos.getZ() - radius; z <= centerPos.getZ() + radius; z++) {
                            BlockPos pos = new BlockPos(x, y, z);
                            if (level.getBlockState(pos).getBlock() == RegistryEntries.BLOCK_CABLE.value()) {
                                level.destroyBlock(pos, false);
                            }
                        }
                    }
                }
            } finally {
                BlockCable.SKIP_NETWORK_INIT = false;
            }
        }

        private static void addPartsToFace(ServerLevel level, BlockPos startPos, int size,
                                          int minX, int maxX, int minY, int maxY, int minZ, int maxZ,
                                          Direction side, Random random, List<BlockPos> updatePositions) {
            for (int x = minX; x <= maxX; x++) {
                for (int y = minY; y <= maxY; y++) {
                    for (int z = minZ; z <= maxZ; z++) {
                        BlockPos pos = startPos.offset(x, y, z);
                        addRandomPartDeferred(level, pos, side, random, updatePositions);
                    }
                }
            }
        }

        private static void addRandomPartDeferred(ServerLevel level, BlockPos pos, Direction side, Random random, List<BlockPos> updatePositions) {
            List<IPartType> partTypes = new ArrayList<>(PartTypeRegistry.getInstance().getPartTypes());

            if (partTypes.isEmpty()) {
                return;
            }

            IPartType partType = partTypes.get(random.nextInt(partTypes.size()));
            ItemStack itemStack = new ItemStack(partType.getItem());
            PartHelpers.addPart(level, pos, side, partType, itemStack);
            updatePositions.add(pos);
        }

        /**
         * Generate a size x size x size cube of logic cables where all cables on the EAST side
         * contain redstone readers, and all cables on the WEST side contain redstone writers.
         * For each reader-writer pair at the same Y and Z coordinates, a variable is created
         * that reads the BOOLEAN_CLOCK aspect from the reader and connects it to the
         * BOOLEAN aspect of the writer at the opposite side.
         */
        public static void generateRedstoneNetwork(ServerLevel level, BlockPos startPos, int size) {
            generateEmptyNetwork(level, startPos, size);

            List<BlockPos> updatePositions = new ArrayList<>();

            // Add redstone readers to EAST side and redstone writers to WEST side
            // EAST side is at x = size - 1, WEST side is at x = 0
            for (int y = 0; y < size; y++) {
                for (int z = 0; z < size; z++) {
                    // EAST side: redstone reader
                    BlockPos eastPos = startPos.offset(size - 1, y, z);
                    PartHelpers.addPart(level, eastPos, Direction.EAST, PartTypes.REDSTONE_READER, new ItemStack(PartTypes.REDSTONE_READER.getItem()));
                    updatePositions.add(eastPos);

                    // WEST side: redstone writer
                    BlockPos westPos = startPos.offset(0, y, z);
                    PartHelpers.addPart(level, westPos, Direction.WEST, PartTypes.REDSTONE_WRITER, new ItemStack(PartTypes.REDSTONE_WRITER.getItem()));
                    updatePositions.add(westPos);
                }
            }

            // Update all positions and create variable connections
            for (BlockPos pos : updatePositions) {
                level.blockUpdated(pos, RegistryEntries.BLOCK_CABLE.value());
            }

            // Create variables connecting readers to writers
            for (int y = 0; y < size; y++) {
                for (int z = 0; z < size; z++) {
                    BlockPos eastPos = startPos.offset(size - 1, y, z);
                    BlockPos westPos = startPos.offset(0, y, z);

                    // Create variable from reader's BOOLEAN_CLOCK aspect
                    org.cyclops.integrateddynamics.api.part.PartPos eastPartPos = org.cyclops.integrateddynamics.api.part.PartPos.of(level, eastPos, Direction.EAST);
                    PartHelpers.PartStateHolder<?, ?> eastPartStateHolder = PartHelpers.getPart(eastPartPos);
                    if (eastPartStateHolder != null) {
                        ItemStack variableCard = GameTestHelpersIntegratedDynamics.createVariableFromReader(level,
                                Aspects.Read.Redstone.BOOLEAN_CLOCK, eastPartStateHolder.getState());

                        // Place variable in writer's BOOLEAN aspect
                        org.cyclops.integrateddynamics.api.part.PartPos westPartPos = org.cyclops.integrateddynamics.api.part.PartPos.of(level, westPos, Direction.WEST);
                        GameTestHelpersIntegratedDynamics.placeVariableInWriter(level, westPartPos,
                                Aspects.Write.Redstone.BOOLEAN, variableCard);
                    }
                }
            }
        }

        /**
         * Generate a size x size x size cube of logic cables where all cables on the EAST side
         * contain redstone readers, and all cables on the WEST side contain redstone writers.
         * For each reader-writer pair at the same Y and Z coordinates, a CHOICE operator is created
         * that reads the BOOLEAN_CLOCK aspect from the reader and chooses between constants 0 and 10.
         * The result is written to the INTEGER aspect of the writer.
         * Variable cards are stored in variable store blocks placed on the SOUTH side of the network,
         * stacked vertically. Each variable store can hold multiple CHOICE operator configurations.
         * All redstone readers have PROPERTY_LENGTH set to 10.
         */
        public static void generateRedstoneNetworkVariables(ServerLevel level, BlockPos startPos, int size) {
            generateEmptyNetwork(level, startPos, size);

            List<BlockPos> updatePositions = new ArrayList<>();

            // Add redstone readers to EAST side and redstone writers to WEST side
            for (int y = 0; y < size; y++) {
                for (int z = 0; z < size; z++) {
                    // EAST side: redstone reader
                    BlockPos eastPos = startPos.offset(size - 1, y, z);
                    PartHelpers.addPart(level, eastPos, Direction.EAST, PartTypes.REDSTONE_READER, new ItemStack(PartTypes.REDSTONE_READER.getItem()));
                    updatePositions.add(eastPos);

                    // WEST side: redstone writer
                    BlockPos westPos = startPos.offset(0, y, z);
                    PartHelpers.addPart(level, westPos, Direction.WEST, PartTypes.REDSTONE_WRITER, new ItemStack(PartTypes.REDSTONE_WRITER.getItem()));
                    updatePositions.add(westPos);
                }
            }

            // Update all positions
            for (BlockPos pos : updatePositions) {
                level.blockUpdated(pos, RegistryEntries.BLOCK_CABLE.value());
            }

            // Create variable stores on the SOUTH side of the network
            // Place stores at (z = size, y varying) stacked vertically
            // Each store can hold 4 items: clock variable, constant 0, constant 10, and choice operator
            int storeX = startPos.getX(); // Aligned with the network
            int storeZ = startPos.getZ() + size; // SOUTH side
            int currentStoreY = startPos.getY();
            int currentSlot = 0;
            BlockEntityVariablestore currentVariableStore = null;
            BlockPos currentStorePos = null;

            // Create variables connecting readers to writers using CHOICE operator
            for (int y = 0; y < size; y++) {
                for (int z = 0; z < size; z++) {
                    BlockPos eastPos = startPos.offset(size - 1, y, z);
                    BlockPos westPos = startPos.offset(0, y, z);

                    // Get or create a new variable store if current one is full
                    if (currentVariableStore == null || currentSlot >= BlockEntityVariablestore.INVENTORY_SIZE) {
                        if (currentSlot >= BlockEntityVariablestore.INVENTORY_SIZE) {
                            // Current store is full, move to next store (stack vertically)
                            currentStoreY++;
                        }

                        currentStorePos = new BlockPos(storeX, currentStoreY, storeZ);
                        level.setBlock(currentStorePos, RegistryEntries.BLOCK_VARIABLE_STORE.get().defaultBlockState(), 2);
                        currentVariableStore = (BlockEntityVariablestore) level.getBlockEntity(currentStorePos);
                        currentSlot = 0;
                    }

                    if (currentVariableStore != null) {
                        // Create variable from reader's BOOLEAN_CLOCK aspect
                        org.cyclops.integrateddynamics.api.part.PartPos eastPartPos = org.cyclops.integrateddynamics.api.part.PartPos.of(level, eastPos, Direction.EAST);
                        PartHelpers.PartStateHolder<?, ?> eastPartStateHolder = PartHelpers.getPart(eastPartPos);

                        if (eastPartStateHolder != null) {
                            // Create constant integer variables (0 and 10) - reuse from first slot if already created
                            ItemStack variable0, variable10;
                            int variable0Id, variable10Id;

                            int currentSlotIncrement;
                            if (currentSlot == 0) {
                                // First time, create and store constants
                                variable0 = GameTestHelpersIntegratedDynamics.createVariableForValue(level, ValueTypes.INTEGER, ValueTypeInteger.ValueInteger.of(0));
                                variable10 = GameTestHelpersIntegratedDynamics.createVariableForValue(level, ValueTypes.INTEGER, ValueTypeInteger.ValueInteger.of(10));
                                currentVariableStore.getInventory().setItem(1, variable0);
                                currentVariableStore.getInventory().setItem(2, variable10);
                                variable0Id = GameTestHelpersIntegratedDynamics.getVariableFacade(level, variable0).getId();
                                variable10Id = GameTestHelpersIntegratedDynamics.getVariableFacade(level, variable10).getId();
                                currentSlotIncrement = 4;
                            } else {
                                // Reuse constants from slots 1 and 2
                                variable0Id = GameTestHelpersIntegratedDynamics.getVariableFacade(level, currentVariableStore.getInventory().getItem(1)).getId();
                                variable10Id = GameTestHelpersIntegratedDynamics.getVariableFacade(level, currentVariableStore.getInventory().getItem(2)).getId();
                                currentSlotIncrement = 2;
                            }

                            // Create variable from reader's BOOLEAN_CLOCK aspect
                            ItemStack variableClock = GameTestHelpersIntegratedDynamics.createVariableFromReader(level,
                                    Aspects.Read.Redstone.BOOLEAN_CLOCK, eastPartStateHolder.getState());
                            currentVariableStore.getInventory().setItem(currentSlot, variableClock);

                            // Create CHOICE operator variable
                            ItemStack variableChoice = GameTestHelpersIntegratedDynamics.createVariableForOperator(level, Operators.GENERAL_CHOICE, new int[]{
                                    GameTestHelpersIntegratedDynamics.getVariableFacade(level, variableClock).getId(),
                                    variable0Id,
                                    variable10Id
                            });
                            currentVariableStore.getInventory().setItem(currentSlot + currentSlotIncrement - 1, variableChoice);

                            // Place CHOICE variable in writer's INTEGER aspect
                            org.cyclops.integrateddynamics.api.part.PartPos westPartPos = org.cyclops.integrateddynamics.api.part.PartPos.of(level, westPos, Direction.WEST);
                            GameTestHelpersIntegratedDynamics.placeVariableInWriter(level, westPartPos,
                                    Aspects.Write.Redstone.INTEGER, variableChoice);

                            currentSlot += currentSlotIncrement;
                        }
                    }
                }
            }

            // Set PROPERTY_LENGTH to 10 for all redstone readers
            for (int y = 0; y < size; y++) {
                for (int z = 0; z < size; z++) {
                    BlockPos eastPos = startPos.offset(size - 1, y, z);
                    PartPos eastPartPos = PartPos.of(level, eastPos, Direction.EAST);
                    GameTestHelpersIntegratedDynamics.setAspectProperty(eastPartPos, Aspects.Read.Redstone.BOOLEAN_CLOCK, AspectReadBuilders.Redstone.PROPERTY_LENGTH, ValueTypeInteger.ValueInteger.of(10));
                }
            }
        }
    }
}

1	package org.cyclops.integrateddynamics.command;
2
3	import com.mojang.brigadier.Command;
4	import com.mojang.brigadier.arguments.IntegerArgumentType;
5	import com.mojang.brigadier.builder.LiteralArgumentBuilder;
6	import com.mojang.brigadier.context.CommandContext;
7	import com.mojang.brigadier.exceptions.CommandSyntaxException;
8	import net.minecraft.ChatFormatting;
9	import net.minecraft.commands.CommandSourceStack;
10	import net.minecraft.commands.Commands;
11	import net.minecraft.core.BlockPos;
12	import net.minecraft.core.Direction;
13	import net.minecraft.network.chat.Component;
14	import net.minecraft.server.level.ServerLevel;
15	import net.minecraft.world.item.ItemStack;
16	import org.cyclops.cyclopscore.command.argument.ArgumentTypeEnum;
17	import org.cyclops.integrateddynamics.RegistryEntries;
18	import org.cyclops.integrateddynamics.api.part.IPartType;
19	import org.cyclops.integrateddynamics.api.part.PartPos;
20	import org.cyclops.integrateddynamics.block.BlockCable;
21	import org.cyclops.integrateddynamics.blockentity.BlockEntityVariablestore;
22	import org.cyclops.integrateddynamics.core.evaluate.operator.Operators;
23	import org.cyclops.integrateddynamics.core.evaluate.variable.ValueTypeInteger;
24	import org.cyclops.integrateddynamics.core.evaluate.variable.ValueTypes;
25	import org.cyclops.integrateddynamics.core.helper.CableHelpers;
26	import org.cyclops.integrateddynamics.core.helper.NetworkHelpers;
27	import org.cyclops.integrateddynamics.core.helper.PartHelpers;
28	import org.cyclops.integrateddynamics.core.part.PartTypeRegistry;
29	import org.cyclops.integrateddynamics.core.part.PartTypes;
30	import org.cyclops.integrateddynamics.gametest.GameTestHelpersIntegratedDynamics;
31	import org.cyclops.integrateddynamics.part.aspect.Aspects;
32	import org.cyclops.integrateddynamics.part.aspect.read.AspectReadBuilders;
33
34	import java.util.ArrayList;
35	import java.util.List;
36	import java.util.Random;
37
38	/**
39	* Command for generating networks with different presets.
40	* @author rubensworks
41	*/
42	public class CommandGenerateNetwork implements Command<CommandSourceStack> {	×
43
44	public static LiteralArgumentBuilder<CommandSourceStack> make() {
45	LiteralArgumentBuilder<CommandSourceStack> builder = Commands.literal("generatenetwork")	3✔
46	.requires((commandSource) -> commandSource.hasPermission(2));	3✔
47
48	// Add the preset subcommand with optional size/radius argument
49	builder.then(Commands.argument("preset", new ArgumentTypeEnum(NetworkPreset.class))	14✔
50	.executes(new CommandGenerateNetworkExecutor(true, false))	4✔
51	.then(Commands.argument("size", IntegerArgumentType.integer(1, 1000))	8✔
52	.executes(new CommandGenerateNetworkExecutor(true, true))));	1✔
53
54	return builder;	2✔
55	}
56
57	@Override
58	public int run(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
59	context.getSource().sendFailure(Component.literal("Please specify a preset: empty, idle, redstoneioclock, or clear")	×
60	.withStyle(ChatFormatting.RED));	×
61	return 0;	×
62	}
63
64	public enum NetworkPreset {	×
65	EMPTY,	×
66	IDLE,	×
67	REDSTONEIOCLOCK,	×
68	REDSTONEIOCLOCKVARIABLES,	×
69	CLEAR	×
70	}
71
72	/**
73	* Executor for the generatenetwork command.
74	*/
75	public static class CommandGenerateNetworkExecutor implements Command<CommandSourceStack> {
76	private final boolean hasPreset;
77	private final boolean hasSize;
78
79	public CommandGenerateNetworkExecutor(boolean hasPreset, boolean hasSize) {	2✔
80	this.hasPreset = hasPreset;	3✔
81	this.hasSize = hasSize;	3✔
82	}	1✔
83
84	@Override
85	public int run(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
86	if (!hasPreset) {	×
87	context.getSource().sendFailure(Component.literal("Please specify a preset: empty, idle, redstoneioclock, or clear")	×
88	.withStyle(ChatFormatting.RED));	×
89	return 0;	×
90	}
91
92	NetworkPreset preset = ArgumentTypeEnum.getValue(context, "preset", NetworkPreset.class);	×
93	ServerLevel level = context.getSource().getLevel();	×
94	BlockPos playerPos = BlockPos.containing(context.getSource().getPosition());	×
95	int size = hasSize ? IntegerArgumentType.getInteger(context, "size") : getDefaultSize(preset);	×
96
97	switch (preset) {	×
98	case EMPTY:
99	context.getSource().sendSuccess(	×
100	() -> Component.literal("Generating network preset: empty (size: " + size + "x" + size + "x" + size + ")")	×
101	.withStyle(ChatFormatting.GREEN),	×
102	true);
103	NetworkGenerationHelper.generateEmptyNetwork(level, playerPos.above(2), size);	×
104	break;	×
105	case IDLE:
106	context.getSource().sendSuccess(	×
107	() -> Component.literal("Generating network preset: idle (size: " + size + "x" + size + "x" + size + ")")	×
108	.withStyle(ChatFormatting.GREEN),	×
109	true);
110	NetworkGenerationHelper.generateIdleNetwork(level, playerPos.above(2), size);	×
111	break;	×
112	case REDSTONEIOCLOCK:
113	context.getSource().sendSuccess(	×
114	() -> Component.literal("Generating network preset: redstoneioclock (size: " + size + "x" + size + "x" + size + ")")	×
115	.withStyle(ChatFormatting.GREEN),	×
116	true);
117	NetworkGenerationHelper.generateRedstoneNetwork(level, playerPos.above(2), size);	×
118	break;	×
119	case REDSTONEIOCLOCKVARIABLES:
120	context.getSource().sendSuccess(	×
121	() -> Component.literal("Generating network preset: redstoneioclockvariables (size: " + size + "x" + size + "x" + size + ")")	×
122	.withStyle(ChatFormatting.GREEN),	×
123	true);
124	NetworkGenerationHelper.generateRedstoneNetworkVariables(level, playerPos.above(2), size);	×
125	break;	×
126	case CLEAR:
127	context.getSource().sendSuccess(	×
128	() -> Component.literal("Clearing cables within radius: " + size)	×
129	.withStyle(ChatFormatting.GREEN),	×
130	true);
131	NetworkGenerationHelper.clearCables(level, playerPos, size);	×
132	break;
133	}
134
135	return 1;	×
136	}
137
138	/**
139	* Get the default size/radius for the given preset.
140	*/
141	private int getDefaultSize(NetworkPreset preset) {
142	return preset == NetworkPreset.CLEAR ? 50 : 25;	×
143	}
144	}
145
146	/**
147	* Helper class for network generation logic, shared between command and game tests.
148	*/
149	public static class NetworkGenerationHelper {	×
150	/**
151	* Generate a size x size x size cube of only logic cables.
152	*/
153	public static void generateEmptyNetwork(ServerLevel level, BlockPos startPos, int size) {
154	List<BlockPos> placedPositions = new ArrayList<>();	×
155
156	BlockCable.SKIP_NETWORK_INIT = true;	×
157	try {
158	for (int x = 0; x < size; x++) {	×
159	for (int y = 0; y < size; y++) {	×
160	for (int z = 0; z < size; z++) {	×
161	BlockPos pos = startPos.offset(x, y, z);	×
162	level.setBlock(pos, RegistryEntries.BLOCK_CABLE.value().defaultBlockState(), 2);	×
163	placedPositions.add(pos);	×
164	}
165	}
166	}
167	} finally {
168	BlockCable.SKIP_NETWORK_INIT = false;	×
169	}
170
171	for (BlockPos pos : placedPositions) {	×
172	CableHelpers.updateConnectionsNeighbours(level, pos, CableHelpers.ALL_SIDES);	×
173	}	×
174
175	NetworkHelpers.initNetwork(level, startPos, null);	×
176	}	×
177
178	/**
179	* Generate a size x size x size cube of logic cables where all cables on the outer sides
180	* contain random parts facing outwards.
181	*/
182	public static void generateIdleNetwork(ServerLevel level, BlockPos startPos, int size) {
183	generateEmptyNetwork(level, startPos, size);	×
184
185	Random random = new Random();	×
186	List<BlockPos> updatePositions = new ArrayList<>();	×
187
188	addPartsToFace(level, startPos, size, 0, size - 1, size - 1, size - 1, 0, size - 1, Direction.UP, random, updatePositions);	×
189	addPartsToFace(level, startPos, size, 0, size - 1, 0, 0, 0, size - 1, Direction.DOWN, random, updatePositions);	×
190	addPartsToFace(level, startPos, size, 0, size - 1, 0, size - 1, 0, 0, Direction.NORTH, random, updatePositions);	×
191	addPartsToFace(level, startPos, size, 0, size - 1, 0, size - 1, size - 1, size - 1, Direction.SOUTH, random, updatePositions);	×
192	addPartsToFace(level, startPos, size, 0, 0, 0, size - 1, 0, size - 1, Direction.WEST, random, updatePositions);	×
193	addPartsToFace(level, startPos, size, size - 1, size - 1, 0, size - 1, 0, size - 1, Direction.EAST, random, updatePositions);	×
194
195	for (BlockPos pos : updatePositions) {	×
196	level.blockUpdated(pos, RegistryEntries.BLOCK_CABLE.value());	×
197	}	×
198	}	×
199
200	/**
201	* Place a single cable block at the given position.
202	*/
203	public static void placeCable(ServerLevel level, BlockPos pos) {
204	level.setBlock(pos, RegistryEntries.BLOCK_CABLE.value().defaultBlockState(), 2);	×
205	}	×
206
207	/**
208	* Add a random part to the NORTH face of a cable at the given position.
209	*/
210	public static void addPartToNorthFace(ServerLevel level, BlockPos pos) {
211	List<IPartType> partTypes = new ArrayList<>(PartTypeRegistry.getInstance().getPartTypes());	×
212
213	if (partTypes.isEmpty()) {	×
214	return;	×
215	}
216
217	Random random = new Random();	×
218	IPartType partType = partTypes.get(random.nextInt(partTypes.size()));	×
219	ItemStack itemStack = new ItemStack(partType.getItem());	×
220	PartHelpers.addPart(level, pos, Direction.NORTH, partType, itemStack);	×
221	}	×
222
223	/**
224	* Clear all cable blocks within a radius of the given position.
225	*/
226	public static void clearCables(ServerLevel level, BlockPos centerPos, int radius) {
227	BlockCable.SKIP_NETWORK_INIT = true;	×
228
229	try {
230	for (int x = centerPos.getX() - radius; x <= centerPos.getX() + radius; x++) {	×
231	for (int y = centerPos.getY() - radius; y <= centerPos.getY() + radius; y++) {	×
232	for (int z = centerPos.getZ() - radius; z <= centerPos.getZ() + radius; z++) {	×
233	BlockPos pos = new BlockPos(x, y, z);	×
234	if (level.getBlockState(pos).getBlock() == RegistryEntries.BLOCK_CABLE.value()) {	×
235	level.destroyBlock(pos, false);	×
236	}
237	}
238	}
239	}
240	} finally {
241	BlockCable.SKIP_NETWORK_INIT = false;	×
242	}
243	}	×
244
245	private static void addPartsToFace(ServerLevel level, BlockPos startPos, int size,
246	int minX, int maxX, int minY, int maxY, int minZ, int maxZ,
247	Direction side, Random random, List<BlockPos> updatePositions) {
248	for (int x = minX; x <= maxX; x++) {	×
249	for (int y = minY; y <= maxY; y++) {	×
250	for (int z = minZ; z <= maxZ; z++) {	×
251	BlockPos pos = startPos.offset(x, y, z);	×
252	addRandomPartDeferred(level, pos, side, random, updatePositions);	×
253	}
254	}
255	}
256	}	×
257
258	private static void addRandomPartDeferred(ServerLevel level, BlockPos pos, Direction side, Random random, List<BlockPos> updatePositions) {
259	List<IPartType> partTypes = new ArrayList<>(PartTypeRegistry.getInstance().getPartTypes());	×
260
261	if (partTypes.isEmpty()) {	×
262	return;	×
263	}
264
265	IPartType partType = partTypes.get(random.nextInt(partTypes.size()));	×
266	ItemStack itemStack = new ItemStack(partType.getItem());	×
267	PartHelpers.addPart(level, pos, side, partType, itemStack);	×
268	updatePositions.add(pos);	×
269	}	×
270
271	/**
272	* Generate a size x size x size cube of logic cables where all cables on the EAST side
273	* contain redstone readers, and all cables on the WEST side contain redstone writers.
274	* For each reader-writer pair at the same Y and Z coordinates, a variable is created
275	* that reads the BOOLEAN_CLOCK aspect from the reader and connects it to the
276	* BOOLEAN aspect of the writer at the opposite side.
277	*/
278	public static void generateRedstoneNetwork(ServerLevel level, BlockPos startPos, int size) {
279	generateEmptyNetwork(level, startPos, size);	×
280
281	List<BlockPos> updatePositions = new ArrayList<>();	×
282
283	// Add redstone readers to EAST side and redstone writers to WEST side
284	// EAST side is at x = size - 1, WEST side is at x = 0
285	for (int y = 0; y < size; y++) {	×
286	for (int z = 0; z < size; z++) {	×
287	// EAST side: redstone reader
288	BlockPos eastPos = startPos.offset(size - 1, y, z);	×
289	PartHelpers.addPart(level, eastPos, Direction.EAST, PartTypes.REDSTONE_READER, new ItemStack(PartTypes.REDSTONE_READER.getItem()));	×
290	updatePositions.add(eastPos);	×
291
292	// WEST side: redstone writer
293	BlockPos westPos = startPos.offset(0, y, z);	×
294	PartHelpers.addPart(level, westPos, Direction.WEST, PartTypes.REDSTONE_WRITER, new ItemStack(PartTypes.REDSTONE_WRITER.getItem()));	×
295	updatePositions.add(westPos);	×
296	}
297	}
298
299	// Update all positions and create variable connections
300	for (BlockPos pos : updatePositions) {	×
301	level.blockUpdated(pos, RegistryEntries.BLOCK_CABLE.value());	×
302	}	×
303
304	// Create variables connecting readers to writers
305	for (int y = 0; y < size; y++) {	×
306	for (int z = 0; z < size; z++) {	×
307	BlockPos eastPos = startPos.offset(size - 1, y, z);	×
308	BlockPos westPos = startPos.offset(0, y, z);	×
309
310	// Create variable from reader's BOOLEAN_CLOCK aspect
311	org.cyclops.integrateddynamics.api.part.PartPos eastPartPos = org.cyclops.integrateddynamics.api.part.PartPos.of(level, eastPos, Direction.EAST);	×
312	PartHelpers.PartStateHolder<?, ?> eastPartStateHolder = PartHelpers.getPart(eastPartPos);	×
313	if (eastPartStateHolder != null) {	×
314	ItemStack variableCard = GameTestHelpersIntegratedDynamics.createVariableFromReader(level,	×
315	Aspects.Read.Redstone.BOOLEAN_CLOCK, eastPartStateHolder.getState());	×
316
317	// Place variable in writer's BOOLEAN aspect
318	org.cyclops.integrateddynamics.api.part.PartPos westPartPos = org.cyclops.integrateddynamics.api.part.PartPos.of(level, westPos, Direction.WEST);	×
319	GameTestHelpersIntegratedDynamics.placeVariableInWriter(level, westPartPos,	×
320	Aspects.Write.Redstone.BOOLEAN, variableCard);
321	}
322	}
323	}
324	}	×
325
326	/**
327	* Generate a size x size x size cube of logic cables where all cables on the EAST side
328	* contain redstone readers, and all cables on the WEST side contain redstone writers.
329	* For each reader-writer pair at the same Y and Z coordinates, a CHOICE operator is created
330	* that reads the BOOLEAN_CLOCK aspect from the reader and chooses between constants 0 and 10.
331	* The result is written to the INTEGER aspect of the writer.
332	* Variable cards are stored in variable store blocks placed on the SOUTH side of the network,
333	* stacked vertically. Each variable store can hold multiple CHOICE operator configurations.
334	* All redstone readers have PROPERTY_LENGTH set to 10.
335	*/
336	public static void generateRedstoneNetworkVariables(ServerLevel level, BlockPos startPos, int size) {
337	generateEmptyNetwork(level, startPos, size);	×
338
339	List<BlockPos> updatePositions = new ArrayList<>();	×
340
341	// Add redstone readers to EAST side and redstone writers to WEST side
342	for (int y = 0; y < size; y++) {	×
343	for (int z = 0; z < size; z++) {	×
344	// EAST side: redstone reader
345	BlockPos eastPos = startPos.offset(size - 1, y, z);	×
346	PartHelpers.addPart(level, eastPos, Direction.EAST, PartTypes.REDSTONE_READER, new ItemStack(PartTypes.REDSTONE_READER.getItem()));	×
347	updatePositions.add(eastPos);	×
348
349	// WEST side: redstone writer
350	BlockPos westPos = startPos.offset(0, y, z);	×
351	PartHelpers.addPart(level, westPos, Direction.WEST, PartTypes.REDSTONE_WRITER, new ItemStack(PartTypes.REDSTONE_WRITER.getItem()));	×
352	updatePositions.add(westPos);	×
353	}
354	}
355
356	// Update all positions
357	for (BlockPos pos : updatePositions) {	×
358	level.blockUpdated(pos, RegistryEntries.BLOCK_CABLE.value());	×
359	}	×
360
361	// Create variable stores on the SOUTH side of the network
362	// Place stores at (z = size, y varying) stacked vertically
363	// Each store can hold 4 items: clock variable, constant 0, constant 10, and choice operator
364	int storeX = startPos.getX(); // Aligned with the network	×
365	int storeZ = startPos.getZ() + size; // SOUTH side	×
366	int currentStoreY = startPos.getY();	×
367	int currentSlot = 0;	×
368	BlockEntityVariablestore currentVariableStore = null;	×
369	BlockPos currentStorePos = null;	×
370
371	// Create variables connecting readers to writers using CHOICE operator
372	for (int y = 0; y < size; y++) {	×
373	for (int z = 0; z < size; z++) {	×
374	BlockPos eastPos = startPos.offset(size - 1, y, z);	×
375	BlockPos westPos = startPos.offset(0, y, z);	×
376
377	// Get or create a new variable store if current one is full
378	if (currentVariableStore == null \|\| currentSlot >= BlockEntityVariablestore.INVENTORY_SIZE) {	×
379	if (currentSlot >= BlockEntityVariablestore.INVENTORY_SIZE) {	×
380	// Current store is full, move to next store (stack vertically)
381	currentStoreY++;	×
382	}
383
384	currentStorePos = new BlockPos(storeX, currentStoreY, storeZ);	×
385	level.setBlock(currentStorePos, RegistryEntries.BLOCK_VARIABLE_STORE.get().defaultBlockState(), 2);	×
386	currentVariableStore = (BlockEntityVariablestore) level.getBlockEntity(currentStorePos);	×
387	currentSlot = 0;	×
388	}
389
390	if (currentVariableStore != null) {	×
391	// Create variable from reader's BOOLEAN_CLOCK aspect
392	org.cyclops.integrateddynamics.api.part.PartPos eastPartPos = org.cyclops.integrateddynamics.api.part.PartPos.of(level, eastPos, Direction.EAST);	×
393	PartHelpers.PartStateHolder<?, ?> eastPartStateHolder = PartHelpers.getPart(eastPartPos);	×
394
395	if (eastPartStateHolder != null) {	×
396	// Create constant integer variables (0 and 10) - reuse from first slot if already created
397	ItemStack variable0, variable10;
398	int variable0Id, variable10Id;
399
400	int currentSlotIncrement;
401	if (currentSlot == 0) {	×
402	// First time, create and store constants
403	variable0 = GameTestHelpersIntegratedDynamics.createVariableForValue(level, ValueTypes.INTEGER, ValueTypeInteger.ValueInteger.of(0));	×
404	variable10 = GameTestHelpersIntegratedDynamics.createVariableForValue(level, ValueTypes.INTEGER, ValueTypeInteger.ValueInteger.of(10));	×
405	currentVariableStore.getInventory().setItem(1, variable0);	×
406	currentVariableStore.getInventory().setItem(2, variable10);	×
407	variable0Id = GameTestHelpersIntegratedDynamics.getVariableFacade(level, variable0).getId();	×
408	variable10Id = GameTestHelpersIntegratedDynamics.getVariableFacade(level, variable10).getId();	×
409	currentSlotIncrement = 4;	×
410	} else {
411	// Reuse constants from slots 1 and 2
412	variable0Id = GameTestHelpersIntegratedDynamics.getVariableFacade(level, currentVariableStore.getInventory().getItem(1)).getId();	×
413	variable10Id = GameTestHelpersIntegratedDynamics.getVariableFacade(level, currentVariableStore.getInventory().getItem(2)).getId();	×
414	currentSlotIncrement = 2;	×
415	}
416
417	// Create variable from reader's BOOLEAN_CLOCK aspect
418	ItemStack variableClock = GameTestHelpersIntegratedDynamics.createVariableFromReader(level,	×
419	Aspects.Read.Redstone.BOOLEAN_CLOCK, eastPartStateHolder.getState());	×
420	currentVariableStore.getInventory().setItem(currentSlot, variableClock);	×
421
422	// Create CHOICE operator variable
423	ItemStack variableChoice = GameTestHelpersIntegratedDynamics.createVariableForOperator(level, Operators.GENERAL_CHOICE, new int[]{	×
424	GameTestHelpersIntegratedDynamics.getVariableFacade(level, variableClock).getId(),	×
425	variable0Id,
426	variable10Id
427	});
428	currentVariableStore.getInventory().setItem(currentSlot + currentSlotIncrement - 1, variableChoice);	×
429
430	// Place CHOICE variable in writer's INTEGER aspect
431	org.cyclops.integrateddynamics.api.part.PartPos westPartPos = org.cyclops.integrateddynamics.api.part.PartPos.of(level, westPos, Direction.WEST);	×
432	GameTestHelpersIntegratedDynamics.placeVariableInWriter(level, westPartPos,	×
433	Aspects.Write.Redstone.INTEGER, variableChoice);
434
435	currentSlot += currentSlotIncrement;	×
436	}
437	}
438	}
439	}
440
441	// Set PROPERTY_LENGTH to 10 for all redstone readers
442	for (int y = 0; y < size; y++) {	×
443	for (int z = 0; z < size; z++) {	×
444	BlockPos eastPos = startPos.offset(size - 1, y, z);	×
445	PartPos eastPartPos = PartPos.of(level, eastPos, Direction.EAST);	×
446	GameTestHelpersIntegratedDynamics.setAspectProperty(eastPartPos, Aspects.Read.Redstone.BOOLEAN_CLOCK, AspectReadBuilders.Redstone.PROPERTY_LENGTH, ValueTypeInteger.ValueInteger.of(10));	×
447	}
448	}
449	}	×
450	}
451	}

CyclopsMC / IntegratedDynamics / 22182377337

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous