22175665670

Committed 19 Feb 2026 09:16AM UTC coverage: 44.465% (+0.004%) from 44.461%

Build # 22175665670

Build Type

push

github

Committed by

rubensworks

Commit Message

WIP

Coverage Stats

2658 of 8848 branches covered (30.04%)

Branch coverage included in aggregate %.

12022 of 24167 relevant lines covered (49.75%)

2.36 hits per line

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

3.97

/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);
        }

        /**
         * Clear all cable blocks within a radius of the given position.
         */
        public static void clearCables(ServerLevel level, BlockPos centerPos, int radius) {
            int radiusSquared = radius * 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);

                            int dx = x - centerPos.getX();
                            int dy = y - centerPos.getY();
                            int dz = z - centerPos.getZ();
                            if (dx * dx + dy * dy + dz * dz <= radiusSquared) {
                                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	* Clear all cable blocks within a radius of the given position.
209	*/
210	public static void clearCables(ServerLevel level, BlockPos centerPos, int radius) {
211	int radiusSquared = radius * radius;	×
212
213	BlockCable.SKIP_NETWORK_INIT = true;	×
214
215	try {
216	for (int x = centerPos.getX() - radius; x <= centerPos.getX() + radius; x++) {	×
217	for (int y = centerPos.getY() - radius; y <= centerPos.getY() + radius; y++) {	×
218	for (int z = centerPos.getZ() - radius; z <= centerPos.getZ() + radius; z++) {	×
219	BlockPos pos = new BlockPos(x, y, z);	×
220
221	int dx = x - centerPos.getX();	×
222	int dy = y - centerPos.getY();	×
223	int dz = z - centerPos.getZ();	×
224	if (dx * dx + dy * dy + dz * dz <= radiusSquared) {	×
225	if (level.getBlockState(pos).getBlock() == RegistryEntries.BLOCK_CABLE.value()) {	×
226	level.destroyBlock(pos, false);	×
227	}
228	}
229	}
230	}
231	}
232	} finally {
233	BlockCable.SKIP_NETWORK_INIT = false;	×
234	}
235	}	×
236
237	private static void addPartsToFace(ServerLevel level, BlockPos startPos, int size,
238	int minX, int maxX, int minY, int maxY, int minZ, int maxZ,
239	Direction side, Random random, List<BlockPos> updatePositions) {
240	for (int x = minX; x <= maxX; x++) {	×
241	for (int y = minY; y <= maxY; y++) {	×
242	for (int z = minZ; z <= maxZ; z++) {	×
243	BlockPos pos = startPos.offset(x, y, z);	×
244	addRandomPartDeferred(level, pos, side, random, updatePositions);	×
245	}
246	}
247	}
248	}	×
249
250	private static void addRandomPartDeferred(ServerLevel level, BlockPos pos, Direction side, Random random, List<BlockPos> updatePositions) {
251	List<IPartType> partTypes = new ArrayList<>(PartTypeRegistry.getInstance().getPartTypes());	×
252
253	if (partTypes.isEmpty()) {	×
254	return;	×
255	}
256
257	IPartType partType = partTypes.get(random.nextInt(partTypes.size()));	×
258	ItemStack itemStack = new ItemStack(partType.getItem());	×
259	PartHelpers.addPart(level, pos, side, partType, itemStack);	×
260	updatePositions.add(pos);	×
261	}	×
262
263	/**
264	* Generate a size x size x size cube of logic cables where all cables on the EAST side
265	* contain redstone readers, and all cables on the WEST side contain redstone writers.
266	* For each reader-writer pair at the same Y and Z coordinates, a variable is created
267	* that reads the BOOLEAN_CLOCK aspect from the reader and connects it to the
268	* BOOLEAN aspect of the writer at the opposite side.
269	*/
270	public static void generateRedstoneNetwork(ServerLevel level, BlockPos startPos, int size) {
271	generateEmptyNetwork(level, startPos, size);	×
272
273	List<BlockPos> updatePositions = new ArrayList<>();	×
274
275	// Add redstone readers to EAST side and redstone writers to WEST side
276	// EAST side is at x = size - 1, WEST side is at x = 0
277	for (int y = 0; y < size; y++) {	×
278	for (int z = 0; z < size; z++) {	×
279	// EAST side: redstone reader
280	BlockPos eastPos = startPos.offset(size - 1, y, z);	×
281	PartHelpers.addPart(level, eastPos, Direction.EAST, PartTypes.REDSTONE_READER, new ItemStack(PartTypes.REDSTONE_READER.getItem()));	×
282	updatePositions.add(eastPos);	×
283
284	// WEST side: redstone writer
285	BlockPos westPos = startPos.offset(0, y, z);	×
286	PartHelpers.addPart(level, westPos, Direction.WEST, PartTypes.REDSTONE_WRITER, new ItemStack(PartTypes.REDSTONE_WRITER.getItem()));	×
287	updatePositions.add(westPos);	×
288	}
289	}
290
291	// Update all positions and create variable connections
292	for (BlockPos pos : updatePositions) {	×
293	level.blockUpdated(pos, RegistryEntries.BLOCK_CABLE.value());	×
294	}	×
295
296	// Create variables connecting readers to writers
297	for (int y = 0; y < size; y++) {	×
298	for (int z = 0; z < size; z++) {	×
299	BlockPos eastPos = startPos.offset(size - 1, y, z);	×
300	BlockPos westPos = startPos.offset(0, y, z);	×
301
302	// Create variable from reader's BOOLEAN_CLOCK aspect
303	org.cyclops.integrateddynamics.api.part.PartPos eastPartPos = org.cyclops.integrateddynamics.api.part.PartPos.of(level, eastPos, Direction.EAST);	×
304	PartHelpers.PartStateHolder<?, ?> eastPartStateHolder = PartHelpers.getPart(eastPartPos);	×
305	if (eastPartStateHolder != null) {	×
306	ItemStack variableCard = GameTestHelpersIntegratedDynamics.createVariableFromReader(level,	×
307	Aspects.Read.Redstone.BOOLEAN_CLOCK, eastPartStateHolder.getState());	×
308
309	// Place variable in writer's BOOLEAN aspect
310	org.cyclops.integrateddynamics.api.part.PartPos westPartPos = org.cyclops.integrateddynamics.api.part.PartPos.of(level, westPos, Direction.WEST);	×
311	GameTestHelpersIntegratedDynamics.placeVariableInWriter(level, westPartPos,	×
312	Aspects.Write.Redstone.BOOLEAN, variableCard);
313	}
314	}
315	}
316	}	×
317
318	/**
319	* Generate a size x size x size cube of logic cables where all cables on the EAST side
320	* contain redstone readers, and all cables on the WEST side contain redstone writers.
321	* For each reader-writer pair at the same Y and Z coordinates, a CHOICE operator is created
322	* that reads the BOOLEAN_CLOCK aspect from the reader and chooses between constants 0 and 10.
323	* The result is written to the INTEGER aspect of the writer.
324	* Variable cards are stored in variable store blocks placed on the SOUTH side of the network,
325	* stacked vertically. Each variable store can hold multiple CHOICE operator configurations.
326	* All redstone readers have PROPERTY_LENGTH set to 10.
327	*/
328	public static void generateRedstoneNetworkVariables(ServerLevel level, BlockPos startPos, int size) {
329	generateEmptyNetwork(level, startPos, size);	×
330
331	List<BlockPos> updatePositions = new ArrayList<>();	×
332
333	// Add redstone readers to EAST side and redstone writers to WEST side
334	for (int y = 0; y < size; y++) {	×
335	for (int z = 0; z < size; z++) {	×
336	// EAST side: redstone reader
337	BlockPos eastPos = startPos.offset(size - 1, y, z);	×
338	PartHelpers.addPart(level, eastPos, Direction.EAST, PartTypes.REDSTONE_READER, new ItemStack(PartTypes.REDSTONE_READER.getItem()));	×
339	updatePositions.add(eastPos);	×
340
341	// WEST side: redstone writer
342	BlockPos westPos = startPos.offset(0, y, z);	×
343	PartHelpers.addPart(level, westPos, Direction.WEST, PartTypes.REDSTONE_WRITER, new ItemStack(PartTypes.REDSTONE_WRITER.getItem()));	×
344	updatePositions.add(westPos);	×
345	}
346	}
347
348	// Update all positions
349	for (BlockPos pos : updatePositions) {	×
350	level.blockUpdated(pos, RegistryEntries.BLOCK_CABLE.value());	×
351	}	×
352
353	// Create variable stores on the SOUTH side of the network
354	// Place stores at (z = size, y varying) stacked vertically
355	// Each store can hold 4 items: clock variable, constant 0, constant 10, and choice operator
356	int storeX = startPos.getX(); // Aligned with the network	×
357	int storeZ = startPos.getZ() + size; // SOUTH side	×
358	int currentStoreY = startPos.getY();	×
359	int currentSlot = 0;	×
360	BlockEntityVariablestore currentVariableStore = null;	×
361	BlockPos currentStorePos = null;	×
362
363	// Create variables connecting readers to writers using CHOICE operator
364	for (int y = 0; y < size; y++) {	×
365	for (int z = 0; z < size; z++) {	×
366	BlockPos eastPos = startPos.offset(size - 1, y, z);	×
367	BlockPos westPos = startPos.offset(0, y, z);	×
368
369	// Get or create a new variable store if current one is full
370	if (currentVariableStore == null \|\| currentSlot >= BlockEntityVariablestore.INVENTORY_SIZE) {	×
371	if (currentSlot >= BlockEntityVariablestore.INVENTORY_SIZE) {	×
372	// Current store is full, move to next store (stack vertically)
373	currentStoreY++;	×
374	}
375
376	currentStorePos = new BlockPos(storeX, currentStoreY, storeZ);	×
377	level.setBlock(currentStorePos, RegistryEntries.BLOCK_VARIABLE_STORE.get().defaultBlockState(), 2);	×
378	currentVariableStore = (BlockEntityVariablestore) level.getBlockEntity(currentStorePos);	×
379	currentSlot = 0;	×
380	}
381
382	if (currentVariableStore != null) {	×
383	// Create variable from reader's BOOLEAN_CLOCK aspect
384	org.cyclops.integrateddynamics.api.part.PartPos eastPartPos = org.cyclops.integrateddynamics.api.part.PartPos.of(level, eastPos, Direction.EAST);	×
385	PartHelpers.PartStateHolder<?, ?> eastPartStateHolder = PartHelpers.getPart(eastPartPos);	×
386
387	if (eastPartStateHolder != null) {	×
388	// Create constant integer variables (0 and 10) - reuse from first slot if already created
389	ItemStack variable0, variable10;
390	int variable0Id, variable10Id;
391
392	int currentSlotIncrement;
393	if (currentSlot == 0) {	×
394	// First time, create and store constants
395	variable0 = GameTestHelpersIntegratedDynamics.createVariableForValue(level, ValueTypes.INTEGER, ValueTypeInteger.ValueInteger.of(0));	×
396	variable10 = GameTestHelpersIntegratedDynamics.createVariableForValue(level, ValueTypes.INTEGER, ValueTypeInteger.ValueInteger.of(10));	×
397	currentVariableStore.getInventory().setItem(1, variable0);	×
398	currentVariableStore.getInventory().setItem(2, variable10);	×
399	variable0Id = GameTestHelpersIntegratedDynamics.getVariableFacade(level, variable0).getId();	×
400	variable10Id = GameTestHelpersIntegratedDynamics.getVariableFacade(level, variable10).getId();	×
401	currentSlotIncrement = 4;	×
402	} else {
403	// Reuse constants from slots 1 and 2
404	variable0Id = GameTestHelpersIntegratedDynamics.getVariableFacade(level, currentVariableStore.getInventory().getItem(1)).getId();	×
405	variable10Id = GameTestHelpersIntegratedDynamics.getVariableFacade(level, currentVariableStore.getInventory().getItem(2)).getId();	×
406	currentSlotIncrement = 2;	×
407	}
408
409	// Create variable from reader's BOOLEAN_CLOCK aspect
410	ItemStack variableClock = GameTestHelpersIntegratedDynamics.createVariableFromReader(level,	×
411	Aspects.Read.Redstone.BOOLEAN_CLOCK, eastPartStateHolder.getState());	×
412	currentVariableStore.getInventory().setItem(currentSlot, variableClock);	×
413
414	// Create CHOICE operator variable
415	ItemStack variableChoice = GameTestHelpersIntegratedDynamics.createVariableForOperator(level, Operators.GENERAL_CHOICE, new int[]{	×
416	GameTestHelpersIntegratedDynamics.getVariableFacade(level, variableClock).getId(),	×
417	variable0Id,
418	variable10Id
419	});
420	currentVariableStore.getInventory().setItem(currentSlot + currentSlotIncrement - 1, variableChoice);	×
421
422	// Place CHOICE variable in writer's INTEGER aspect
423	org.cyclops.integrateddynamics.api.part.PartPos westPartPos = org.cyclops.integrateddynamics.api.part.PartPos.of(level, westPos, Direction.WEST);	×
424	GameTestHelpersIntegratedDynamics.placeVariableInWriter(level, westPartPos,	×
425	Aspects.Write.Redstone.INTEGER, variableChoice);
426
427	currentSlot += currentSlotIncrement;	×
428	}
429	}
430	}
431	}
432
433	// Set PROPERTY_LENGTH to 10 for all redstone readers
434	for (int y = 0; y < size; y++) {	×
435	for (int z = 0; z < size; z++) {	×
436	BlockPos eastPos = startPos.offset(size - 1, y, z);	×
437	PartPos eastPartPos = PartPos.of(level, eastPos, Direction.EAST);	×
438	GameTestHelpersIntegratedDynamics.setAspectProperty(eastPartPos, Aspects.Read.Redstone.BOOLEAN_CLOCK, AspectReadBuilders.Redstone.PROPERTY_LENGTH, ValueTypeInteger.ValueInteger.of(10));	×
439	}
440	}
441	}	×
442	}
443	}

CyclopsMC / IntegratedDynamics / 22175665670

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