24201752325

Committed 09 Apr 2026 04:36PM UTC coverage: 53.655% (+0.01%) from 53.644%

Build # 24201752325

Build Type

push

github

Committed by

web-flow

Commit Message

Fix intermittent day/night game test failures by explicitly overriding world time in each test (#1645)

Coverage Stats

3051 of 8935 branches covered (34.15%)

Branch coverage included in aggregate %.

18706 of 31615 relevant lines covered (59.17%)

3.07 hits per line

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

61.87

/src/main/java/org/cyclops/integrateddynamics/block/BlockCable.java

package org.cyclops.integrateddynamics.block;

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import com.mojang.serialization.MapCodec;
import net.minecraft.client.renderer.chunk.RenderSectionRegion;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.util.RandomSource;
import net.minecraft.world.InteractionHand;
import net.minecraft.world.InteractionResult;
import net.minecraft.world.entity.LivingEntity;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.item.context.BlockPlaceContext;
import net.minecraft.world.level.*;
import net.minecraft.world.level.block.BaseEntityBlock;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.RenderShape;
import net.minecraft.world.level.block.SimpleWaterloggedBlock;
import net.minecraft.world.level.block.entity.BlockEntity;
import net.minecraft.world.level.block.entity.BlockEntityTicker;
import net.minecraft.world.level.block.entity.BlockEntityType;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.block.state.StateDefinition;
import net.minecraft.world.level.block.state.properties.BlockStateProperties;
import net.minecraft.world.level.block.state.properties.BooleanProperty;
import net.minecraft.world.level.material.Fluid;
import net.minecraft.world.level.material.FluidState;
import net.minecraft.world.level.material.Fluids;
import net.minecraft.world.level.redstone.Orientation;
import net.minecraft.world.phys.AABB;
import net.minecraft.world.phys.BlockHitResult;
import net.minecraft.world.phys.shapes.*;
import net.neoforged.neoforge.common.extensions.ILevelExtension;
import net.neoforged.neoforge.model.data.ModelProperty;
import org.cyclops.cyclopscore.block.BlockWithEntity;
import org.cyclops.cyclopscore.datastructure.EnumFacingMap;
import org.cyclops.cyclopscore.helper.IModHelpers;
import org.cyclops.cyclopscore.helper.IModHelpersNeoForge;
import org.cyclops.integrateddynamics.Capabilities;
import org.cyclops.integrateddynamics.GeneralConfig;
import org.cyclops.integrateddynamics.RegistryEntries;
import org.cyclops.integrateddynamics.api.block.IDynamicLight;
import org.cyclops.integrateddynamics.api.block.IDynamicRedstone;
import org.cyclops.integrateddynamics.api.block.cable.ICableFakeable;
import org.cyclops.integrateddynamics.api.part.IPartContainer;
import org.cyclops.integrateddynamics.api.part.IPartState;
import org.cyclops.integrateddynamics.api.part.IPartType;
import org.cyclops.integrateddynamics.api.part.PartRenderPosition;
import org.cyclops.integrateddynamics.block.shapes.*;
import org.cyclops.integrateddynamics.client.model.CableModel;
import org.cyclops.integrateddynamics.client.model.IRenderState;
import org.cyclops.integrateddynamics.core.block.BlockRayTraceResultComponent;
import org.cyclops.integrateddynamics.core.block.VoxelShapeComponents;
import org.cyclops.integrateddynamics.core.block.VoxelShapeComponentsFactory;
import org.cyclops.integrateddynamics.core.blockentity.BlockEntityMultipartTicking;
import org.cyclops.integrateddynamics.core.helper.CableHelpers;
import org.cyclops.integrateddynamics.core.helper.Helpers;
import org.cyclops.integrateddynamics.core.helper.NetworkHelpers;
import org.cyclops.integrateddynamics.core.helper.PartHelpers;

import javax.annotation.Nullable;
import java.util.Iterator;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.TimeUnit;

/**
 * A block that is built up from different parts.
 * This block refers to a ticking part entity.
 * @author rubensworks
 */
public class BlockCable extends BlockWithEntity implements SimpleWaterloggedBlock {

    public static final MapCodec<BlockCable> CODEC = simpleCodec(BlockCable::new);

    public static final float BLOCK_HARDNESS = 3.0F;

    public static final BooleanProperty WATERLOGGED = BlockStateProperties.WATERLOGGED;

    // Model Properties
    public static final ModelProperty<Boolean> REALCABLE = new ModelProperty<>();
    public static final ModelProperty<Boolean>[] CONNECTED = new ModelProperty[6];
    public static final ModelProperty<PartRenderPosition>[] PART_RENDERPOSITIONS = new ModelProperty[6];
    public static final ModelProperty<Optional<BlockState>> FACADE = new ModelProperty<>();
    static {
        for(Direction side : Direction.values()) {
            CONNECTED[side.ordinal()] = new ModelProperty<>();
            PART_RENDERPOSITIONS[side.ordinal()] = new ModelProperty<>();
        }
    }
    public static final ModelProperty<IPartContainer> PARTCONTAINER = new ModelProperty<>();
    public static final ModelProperty<IRenderState> RENDERSTATE = new ModelProperty<>();

    // Collision boxes
    public final static AABB CABLE_CENTER_BOUNDINGBOX = new AABB(
            CableModel.MIN, CableModel.MIN, CableModel.MIN, CableModel.MAX, CableModel.MAX, CableModel.MAX);
    private final static EnumFacingMap<AABB> CABLE_SIDE_BOUNDINGBOXES = EnumFacingMap.forAllValues(
            new AABB(CableModel.MIN, 0, CableModel.MIN, CableModel.MAX, CableModel.MIN, CableModel.MAX), // DOWN
            new AABB(CableModel.MIN, CableModel.MAX, CableModel.MIN, CableModel.MAX, 1, CableModel.MAX), // UP
            new AABB(CableModel.MIN, CableModel.MIN, 0, CableModel.MAX, CableModel.MAX, CableModel.MIN), // NORTH
            new AABB(CableModel.MIN, CableModel.MAX, CableModel.MAX, CableModel.MAX, CableModel.MIN, 1), // SOUTH
            new AABB(0, CableModel.MIN, CableModel.MIN, CableModel.MIN, CableModel.MAX, CableModel.MAX), // WEST
            new AABB(CableModel.MAX, CableModel.MIN, CableModel.MIN, 1, CableModel.MAX, CableModel.MAX) // EAST
    );

    private final VoxelShapeComponentsFactory voxelShapeComponentsFactory = new VoxelShapeComponentsFactory(
            new VoxelShapeComponentsFactoryHandlerCableCenter(),
            new VoxelShapeComponentsFactoryHandlerCableConnections(),
            new VoxelShapeComponentsFactoryHandlerParts(),
            new VoxelShapeComponentsFactoryHandlerFacade()
    );

    private boolean disableCollisionBox = false;

    public void setDisableCollisionBox(boolean disableCollisionBox) {
        this.disableCollisionBox = disableCollisionBox;
    }

    /**
     * Flag to skip expensive network initialization during bulk cable placement.
     * When true, onCableAdded calls are skipped in onPlace.
     * Network initialization should be done manually after all cables are placed.
     */
    public static boolean SKIP_NETWORK_INIT = false;

    public BlockCable(Properties properties) {
        super(properties, BlockEntityMultipartTicking::new);
        this.registerDefaultState(this.stateDefinition.any().setValue(WATERLOGGED, false));
    }

    @Override
    protected MapCodec<? extends BaseEntityBlock> codec() {
        return CODEC;
    }

    @Override
    public boolean useShapeForLightOcclusion(BlockState p_60576_) {
        return true;
    }

    @Override
    @Nullable
    public <T extends BlockEntity> BlockEntityTicker<T> getTicker(Level level, BlockState blockState, BlockEntityType<T> blockEntityType) {
        return level.isClientSide() ? null : createTickerHelper(blockEntityType, RegistryEntries.BLOCK_ENTITY_MULTIPART_TICKING.get(), new BlockEntityMultipartTicking.Ticker<>());
    }

    @Override
    protected void createBlockStateDefinition(StateDefinition.Builder<Block, BlockState> builder) {
        super.createBlockStateDefinition(builder);
        builder.add(WATERLOGGED);
    }

    @Override
    protected BlockState updateShape(BlockState state, LevelReader level, ScheduledTickAccess scheduledTickAccess, BlockPos pos, Direction direction, BlockPos neighborPos, BlockState neighborState, RandomSource random) {
        if (level instanceof ServerLevel serverLevel) {
            if (state.getValue(WATERLOGGED)) {
                serverLevel.scheduleTick(pos, Fluids.WATER, Fluids.WATER.getTickDelay(level));
            }
            NetworkHelpers.onElementProviderBlockNeighborChange(serverLevel, pos, direction);
        }
        return super.updateShape(state, level, scheduledTickAccess, pos, direction, neighborPos, neighborState, random);
    }

    @Override
    public BlockState getStateForPlacement(BlockPlaceContext context) {
        FluidState ifluidstate = context.getLevel().getFluidState(context.getClickedPos());
        return this.defaultBlockState().setValue(WATERLOGGED, ifluidstate.getType() == Fluids.WATER);
    }

    @Override
    public FluidState getFluidState(BlockState state) {
        return state.getValue(WATERLOGGED) ? Fluids.WATER.getSource(false) : super.getFluidState(state);
    }

    @Override
    public boolean canPlaceLiquid(@org.jetbrains.annotations.Nullable LivingEntity entity, BlockGetter worldIn, BlockPos pos, BlockState blockState, Fluid fluidIn) {
        return !blockState.getValue(BlockStateProperties.WATERLOGGED) && fluidIn == Fluids.WATER
                && !(worldIn instanceof ILevelExtension levelExtension && CableHelpers.hasFacade(levelExtension, pos, blockState));
    }

    @Override
    public void onBlockExploded(BlockState state, ServerLevel world, BlockPos blockPos, Explosion explosion) {
        CableHelpers.setRemovingCable(true);
        CableHelpers.onCableRemoving(world, blockPos, true, false, state, world.getBlockEntity(blockPos));
        super.onBlockExploded(state, world, blockPos, explosion);
        CableHelpers.onCableRemoved(world, blockPos);
        CableHelpers.setRemovingCable(false);
    }

    @Override
    public boolean onDestroyedByPlayer(BlockState state, Level world, BlockPos pos, Player player, ItemStack toolStack, boolean willHarvest, FluidState fluid) {
        BlockRayTraceResultComponent rayTraceResult = getSelectedShape(state, world, pos, CollisionContext.of(player))
                .rayTrace(pos, player);
        if (rayTraceResult != null && rayTraceResult.getComponent().destroy(world, pos, player, false)) {
            return false;
        }
        return rayTraceResult != null && super.onDestroyedByPlayer(state, world, pos, player, toolStack, willHarvest, fluid);
    }

    @Override
    protected void affectNeighborsAfterRemoval(BlockState state, ServerLevel level, BlockPos pos, boolean movedByPiston) {
        super.affectNeighborsAfterRemoval(state, level, pos, movedByPiston);

        if (!CableHelpers.isRemovingCable() && !SKIP_NETWORK_INIT) {
            CableHelpers.onCableRemoved(level, pos);
        }
    }

    @Override
    protected InteractionResult useItemOn(ItemStack pStack, BlockState pState, Level pLevel, BlockPos pPos, Player pPlayer, InteractionHand pHand, BlockHitResult pHitResult) {
        /*
            Wrench: sneak + right-click anywhere on cable to remove cable
                    right-click on a cable side to disconnect on that side
                    sneak + right-click on part to remove that part
            No wrench: right-click to open GUI
         */
        BlockEntityMultipartTicking tile = IModHelpers.get().getBlockEntityHelpers().get(pLevel, pPos, BlockEntityMultipartTicking.class).orElse(null);
        if(tile != null) {
            BlockRayTraceResultComponent rayTraceResult = getSelectedShape(pState, pLevel, pPos, CollisionContext.of(pPlayer))
                    .rayTrace(pPos, pPlayer);
            if(rayTraceResult != null) {
                InteractionResult actionResultType = rayTraceResult.getComponent().onBlockActivated(pState, pLevel, pPos, pPlayer, pHand, rayTraceResult);
                if (actionResultType.consumesAction()) {
                    return actionResultType;
                }
            }
        }
        return super.useItemOn(pStack, pState, pLevel, pPos, pPlayer, pHand, pHitResult);
    }

    @Override
    public void onPlace(BlockState state, Level world, BlockPos pos, BlockState oldState, boolean isMoving) {
        super.onPlace(state, world, pos, oldState, isMoving);
        if (!world.isClientSide() && !SKIP_NETWORK_INIT) {
            ICableFakeable cableFakeable = CableHelpers.getCableFakeable(world, pos, null).orElse(null);
            if (cableFakeable != null && cableFakeable.isRealCable()) {
                CableHelpers.onCableAdded(world, pos);
            }
        }
    }

    @Override
    public void setPlacedBy(Level world, BlockPos pos, BlockState state, LivingEntity placer, ItemStack itemStack) {
        super.setPlacedBy(world, pos, state, placer, itemStack);
        if (!world.isClientSide()) {
            CableHelpers.onCableAddedByPlayer(world, pos, placer);
        }
    }

    @Override
    public ItemStack getCloneItemStack(LevelReader level, BlockPos pos, BlockState state, boolean includeData, Player player) {
        BlockRayTraceResultComponent rayTraceResult = getSelectedShape(state, level, pos, CollisionContext.of(player))
                .rayTrace(pos, player);
        if(rayTraceResult != null && level instanceof Level levelReal) {
            return rayTraceResult.getComponent().getCloneItemStack(levelReal, pos);
        }
        return super.getCloneItemStack(level, pos, state, includeData, player);
    }

    @Override
    protected void neighborChanged(BlockState state, Level level, BlockPos pos, Block neighborBlock, @org.jetbrains.annotations.Nullable Orientation orientation, boolean movedByPiston) {
        super.neighborChanged(state, level, pos, neighborBlock, orientation, movedByPiston);
        NetworkHelpers.onElementProviderBlockNeighborChange(level, pos, orientation != null ? orientation.getFront().getOpposite() : null);
    }

    @Override
    public void onNeighborChange(BlockState state, LevelReader world, BlockPos pos, BlockPos neighbor) {
        super.onNeighborChange(state, world, pos, neighbor);
        if (world instanceof Level level) {
            NetworkHelpers.onElementProviderBlockNeighborChange(level, pos, null);
        }
    }

    @Override
    public void tick(BlockState state, ServerLevel world, BlockPos pos, RandomSource rand) {
        super.tick(state, world, pos, rand);
        IModHelpers.get().getBlockEntityHelpers().get(world, pos, BlockEntityMultipartTicking.class)
                .ifPresent(tile -> {
                    for (Map.Entry<Direction, PartHelpers.PartStateHolder<?, ?>> entry : tile
                            .getPartContainer().getPartData().entrySet()) {
                        updateTickPart(entry.getValue().getPart(), world, pos, entry.getValue().getState(), rand);
                    }
                });
    }

    protected void updateTickPart(IPartType partType, Level world, BlockPos pos, IPartState partState, RandomSource random) {
        partType.updateTick(world, pos, partState, random);
    }

    /* --------------- Start shapes and rendering --------------- */

    public AABB getCableBoundingBox(Direction side) {
        if (side == null) {
            return CABLE_CENTER_BOUNDINGBOX;
        } else {
            return CABLE_SIDE_BOUNDINGBOXES.get(side);
        }
    }

    public VoxelShapeComponents getSelectedShape(BlockState blockState, BlockGetter world, BlockPos pos, CollisionContext selectionContext) {
        return voxelShapeComponentsFactory.createShape(blockState, world, pos, selectionContext);
    }

    private final Cache<String, VoxelShape> CACHE_COLLISION_SHAPES = CacheBuilder.newBuilder()
            .expireAfterAccess(1, TimeUnit.MINUTES)
            .build();

    @Override
    public VoxelShape getShape(BlockState state, BlockGetter world, BlockPos pos, CollisionContext selectionContext) {
        VoxelShapeComponents selectedShape = getSelectedShape(state, world, pos, selectionContext);
        BlockRayTraceResultComponent rayTraceResult = selectedShape.rayTrace(pos, selectionContext instanceof EntityCollisionContext ? ((EntityCollisionContext) selectionContext).getEntity() : null);
        if (rayTraceResult != null) {
            return rayTraceResult.getComponent().getShape(state, world, pos, selectionContext);
        }

        String cableState = selectedShape.getStateId();

        // Cache the operations below, as they are too expensive to execute each render tick
        try {
            return CACHE_COLLISION_SHAPES.get(cableState, () -> {
            // Combine all VoxelShapes using IBooleanFunction.OR,
            // because for some reason our VoxelShapeComponents aggregator does not handle collisions properly.
            // This can probably be fixed, but I spent too much time on this already, and the current solution works just fine.
            Iterator<VoxelShape> it = selectedShape.iterator();
            if (!it.hasNext()) {
                return Shapes.empty();
            }
            VoxelShape shape = it.next();
            while (it.hasNext()) {
                shape = Shapes.join(shape, it.next(), BooleanOp.OR);
            }
            return shape.optimize();
            });
        } catch (Exception e) {
            return Helpers.sneakyThrow(e);
        }
    }

    @Override
    public VoxelShape getCollisionShape(BlockState blockState, BlockGetter world, BlockPos pos, CollisionContext selectionContext) {
        return (disableCollisionBox || GeneralConfig.disableCableCollision) ? Shapes.empty() : super.getCollisionShape(blockState, world, pos, selectionContext);
    }

    @Override
    public boolean hasDynamicShape() {
        return BlockCableConfig.dynamicShape;
    }

    @Override
    public RenderShape getRenderShape(BlockState blockState) {
        return RenderShape.MODEL;
    }

    @Override
    protected VoxelShape getBlockSupportShape(BlockState pState, BlockGetter pLevel, BlockPos pPos) {
        return this.getShape(pState, pLevel, pPos, new CollisionContextBlockSupport());
    }

    @Override
    public boolean shouldDisplayFluidOverlay(BlockState state, BlockAndLightGetter level, BlockPos pos, FluidState fluidState) {
        return level instanceof RenderSectionRegion renderSectionRegion && CableHelpers.getFacade(renderSectionRegion.level, pos, state).isPresent();
    }

    /* --------------- Start IDynamicRedstone --------------- */

    @SuppressWarnings("deprecation")
    @Override
    public boolean isSignalSource(BlockState blockState) {
        return true;
    }

    @Override
    public boolean canConnectRedstone(BlockState blockState, BlockGetter world, BlockPos pos, Direction side) {
        if (world instanceof ILevelExtension levelExtension) {
            if (side == null) {
                for (Direction dummySide : Direction.values()) {
                    IDynamicRedstone dynamicRedstone = IModHelpersNeoForge.get().getCapabilityHelpers().getCapability(levelExtension, pos, dummySide, Capabilities.DynamicRedstone.BLOCK).orElse(null);
                    if (dynamicRedstone != null && (dynamicRedstone.getRedstoneLevel() >= 0 || dynamicRedstone.isAllowRedstoneInput())) {
                        return true;
                    }
                }
                return false;
            }
            IDynamicRedstone dynamicRedstone = IModHelpersNeoForge.get().getCapabilityHelpers().getCapability(levelExtension, pos, side.getOpposite(), Capabilities.DynamicRedstone.BLOCK).orElse(null);
            return dynamicRedstone != null && (dynamicRedstone.getRedstoneLevel() >= 0 || dynamicRedstone.isAllowRedstoneInput());
        }
        return false;
    }

    @SuppressWarnings("deprecation")
    @Override
    public int getDirectSignal(BlockState blockState, BlockGetter world, BlockPos pos, Direction side) {
        if (world instanceof ILevelExtension levelExtension) {
            IDynamicRedstone dynamicRedstone = IModHelpersNeoForge.get().getCapabilityHelpers().getCapability(levelExtension, pos, side.getOpposite(), Capabilities.DynamicRedstone.BLOCK).orElse(null);
            return dynamicRedstone != null && dynamicRedstone.isDirect() ? dynamicRedstone.getRedstoneLevel() : 0;
        }
        return 0;
    }

    @SuppressWarnings("deprecation")
    @Override
    public int getSignal(BlockState blockState, BlockGetter world, BlockPos pos, Direction side) {
        if (world instanceof ILevelExtension levelExtension) {
            IDynamicRedstone dynamicRedstone = IModHelpersNeoForge.get().getCapabilityHelpers().getCapability(levelExtension, pos, side.getOpposite(), Capabilities.DynamicRedstone.BLOCK).orElse(null);
            return dynamicRedstone != null ? dynamicRedstone.getRedstoneLevel() : 0;
        }
        return 0;
    }

    /* --------------- Start IDynamicLight --------------- */

    @Override
    public int getLightEmission(BlockState blockState, BlockGetter world, BlockPos pos) {
        int light = 0;
        if (world instanceof ILevelExtension levelExtension) {
            for (Direction side : Direction.values()) {
                IDynamicLight dynamicLight = levelExtension.getCapability(Capabilities.DynamicLight.BLOCK, pos, blockState, null, side);
                if (dynamicLight != null) {
                    light = Math.max(light, dynamicLight.getLightLevel());
                }
            }
        }
        return light;
    }

}

1	package org.cyclops.integrateddynamics.block;
2
3	import com.google.common.cache.Cache;
4	import com.google.common.cache.CacheBuilder;
5	import com.mojang.serialization.MapCodec;
6	import net.minecraft.client.renderer.chunk.RenderSectionRegion;
7	import net.minecraft.core.BlockPos;
8	import net.minecraft.core.Direction;
9	import net.minecraft.server.level.ServerLevel;
10	import net.minecraft.util.RandomSource;
11	import net.minecraft.world.InteractionHand;
12	import net.minecraft.world.InteractionResult;
13	import net.minecraft.world.entity.LivingEntity;
14	import net.minecraft.world.entity.player.Player;
15	import net.minecraft.world.item.ItemStack;
16	import net.minecraft.world.item.context.BlockPlaceContext;
17	import net.minecraft.world.level.*;
18	import net.minecraft.world.level.block.BaseEntityBlock;
19	import net.minecraft.world.level.block.Block;
20	import net.minecraft.world.level.block.RenderShape;
21	import net.minecraft.world.level.block.SimpleWaterloggedBlock;
22	import net.minecraft.world.level.block.entity.BlockEntity;
23	import net.minecraft.world.level.block.entity.BlockEntityTicker;
24	import net.minecraft.world.level.block.entity.BlockEntityType;
25	import net.minecraft.world.level.block.state.BlockState;
26	import net.minecraft.world.level.block.state.StateDefinition;
27	import net.minecraft.world.level.block.state.properties.BlockStateProperties;
28	import net.minecraft.world.level.block.state.properties.BooleanProperty;
29	import net.minecraft.world.level.material.Fluid;
30	import net.minecraft.world.level.material.FluidState;
31	import net.minecraft.world.level.material.Fluids;
32	import net.minecraft.world.level.redstone.Orientation;
33	import net.minecraft.world.phys.AABB;
34	import net.minecraft.world.phys.BlockHitResult;
35	import net.minecraft.world.phys.shapes.*;
36	import net.neoforged.neoforge.common.extensions.ILevelExtension;
37	import net.neoforged.neoforge.model.data.ModelProperty;
38	import org.cyclops.cyclopscore.block.BlockWithEntity;
39	import org.cyclops.cyclopscore.datastructure.EnumFacingMap;
40	import org.cyclops.cyclopscore.helper.IModHelpers;
41	import org.cyclops.cyclopscore.helper.IModHelpersNeoForge;
42	import org.cyclops.integrateddynamics.Capabilities;
43	import org.cyclops.integrateddynamics.GeneralConfig;
44	import org.cyclops.integrateddynamics.RegistryEntries;
45	import org.cyclops.integrateddynamics.api.block.IDynamicLight;
46	import org.cyclops.integrateddynamics.api.block.IDynamicRedstone;
47	import org.cyclops.integrateddynamics.api.block.cable.ICableFakeable;
48	import org.cyclops.integrateddynamics.api.part.IPartContainer;
49	import org.cyclops.integrateddynamics.api.part.IPartState;
50	import org.cyclops.integrateddynamics.api.part.IPartType;
51	import org.cyclops.integrateddynamics.api.part.PartRenderPosition;
52	import org.cyclops.integrateddynamics.block.shapes.*;
53	import org.cyclops.integrateddynamics.client.model.CableModel;
54	import org.cyclops.integrateddynamics.client.model.IRenderState;
55	import org.cyclops.integrateddynamics.core.block.BlockRayTraceResultComponent;
56	import org.cyclops.integrateddynamics.core.block.VoxelShapeComponents;
57	import org.cyclops.integrateddynamics.core.block.VoxelShapeComponentsFactory;
58	import org.cyclops.integrateddynamics.core.blockentity.BlockEntityMultipartTicking;
59	import org.cyclops.integrateddynamics.core.helper.CableHelpers;
60	import org.cyclops.integrateddynamics.core.helper.Helpers;
61	import org.cyclops.integrateddynamics.core.helper.NetworkHelpers;
62	import org.cyclops.integrateddynamics.core.helper.PartHelpers;
63
64	import javax.annotation.Nullable;
65	import java.util.Iterator;
66	import java.util.Map;
67	import java.util.Optional;
68	import java.util.concurrent.TimeUnit;
69
70	/**
71	* A block that is built up from different parts.
72	* This block refers to a ticking part entity.
73	* @author rubensworks
74	*/
75	public class BlockCable extends BlockWithEntity implements SimpleWaterloggedBlock {
76
77	public static final MapCodec<BlockCable> CODEC = simpleCodec(BlockCable::new);	3✔
78
79	public static final float BLOCK_HARDNESS = 3.0F;
80
81	public static final BooleanProperty WATERLOGGED = BlockStateProperties.WATERLOGGED;	2✔
82
83	// Model Properties
84	public static final ModelProperty<Boolean> REALCABLE = new ModelProperty<>();	4✔
85	public static final ModelProperty<Boolean>[] CONNECTED = new ModelProperty[6];	3✔
86	public static final ModelProperty<PartRenderPosition>[] PART_RENDERPOSITIONS = new ModelProperty[6];	3✔
87	public static final ModelProperty<Optional<BlockState>> FACADE = new ModelProperty<>();	4✔
88	static {
89	for(Direction side : Direction.values()) {	16✔
90	CONNECTED[side.ordinal()] = new ModelProperty<>();	7✔
91	PART_RENDERPOSITIONS[side.ordinal()] = new ModelProperty<>();	7✔
92	}
93	}
94	public static final ModelProperty<IPartContainer> PARTCONTAINER = new ModelProperty<>();	4✔
95	public static final ModelProperty<IRenderState> RENDERSTATE = new ModelProperty<>();	4✔
96
97	// Collision boxes
98	public final static AABB CABLE_CENTER_BOUNDINGBOX = new AABB(	10✔
99	CableModel.MIN, CableModel.MIN, CableModel.MIN, CableModel.MAX, CableModel.MAX, CableModel.MAX);
100	private final static EnumFacingMap<AABB> CABLE_SIDE_BOUNDINGBOXES = EnumFacingMap.forAllValues(	56✔
101	new AABB(CableModel.MIN, 0, CableModel.MIN, CableModel.MAX, CableModel.MIN, CableModel.MAX), // DOWN
102	new AABB(CableModel.MIN, CableModel.MAX, CableModel.MIN, CableModel.MAX, 1, CableModel.MAX), // UP
103	new AABB(CableModel.MIN, CableModel.MIN, 0, CableModel.MAX, CableModel.MAX, CableModel.MIN), // NORTH
104	new AABB(CableModel.MIN, CableModel.MAX, CableModel.MAX, CableModel.MAX, CableModel.MIN, 1), // SOUTH
105	new AABB(0, CableModel.MIN, CableModel.MIN, CableModel.MIN, CableModel.MAX, CableModel.MAX), // WEST
106	new AABB(CableModel.MAX, CableModel.MIN, CableModel.MIN, 1, CableModel.MAX, CableModel.MAX) // EAST
107	);
108
109	private final VoxelShapeComponentsFactory voxelShapeComponentsFactory = new VoxelShapeComponentsFactory(	31✔
110	new VoxelShapeComponentsFactoryHandlerCableCenter(),
111	new VoxelShapeComponentsFactoryHandlerCableConnections(),
112	new VoxelShapeComponentsFactoryHandlerParts(),
113	new VoxelShapeComponentsFactoryHandlerFacade()
114	);
115
116	private boolean disableCollisionBox = false;	3✔
117
118	public void setDisableCollisionBox(boolean disableCollisionBox) {
119	this.disableCollisionBox = disableCollisionBox;	3✔
120	}	1✔
121
122	/**
123	* Flag to skip expensive network initialization during bulk cable placement.
124	* When true, onCableAdded calls are skipped in onPlace.
125	* Network initialization should be done manually after all cables are placed.
126	*/
127	public static boolean SKIP_NETWORK_INIT = false;	3✔
128
129	public BlockCable(Properties properties) {
130	super(properties, BlockEntityMultipartTicking::new);	4✔
131	this.registerDefaultState(this.stateDefinition.any().setValue(WATERLOGGED, false));	11✔
132	}	1✔
133
134	@Override
135	protected MapCodec<? extends BaseEntityBlock> codec() {
136	return CODEC;	×
137	}
138
139	@Override
140	public boolean useShapeForLightOcclusion(BlockState p_60576_) {
141	return true;	2✔
142	}
143
144	@Override
145	@Nullable
146	public <T extends BlockEntity> BlockEntityTicker<T> getTicker(Level level, BlockState blockState, BlockEntityType<T> blockEntityType) {
147	return level.isClientSide() ? null : createTickerHelper(blockEntityType, RegistryEntries.BLOCK_ENTITY_MULTIPART_TICKING.get(), new BlockEntityMultipartTicking.Ticker<>());	12!
148	}
149
150	@Override
151	protected void createBlockStateDefinition(StateDefinition.Builder<Block, BlockState> builder) {
152	super.createBlockStateDefinition(builder);	3✔
153	builder.add(WATERLOGGED);	9✔
154	}	1✔
155
156	@Override
157	protected BlockState updateShape(BlockState state, LevelReader level, ScheduledTickAccess scheduledTickAccess, BlockPos pos, Direction direction, BlockPos neighborPos, BlockState neighborState, RandomSource random) {
158	if (level instanceof ServerLevel serverLevel) {	6!
159	if (state.getValue(WATERLOGGED)) {	6!
160	serverLevel.scheduleTick(pos, Fluids.WATER, Fluids.WATER.getTickDelay(level));	×
161	}
162	NetworkHelpers.onElementProviderBlockNeighborChange(serverLevel, pos, direction);	4✔
163	}
164	return super.updateShape(state, level, scheduledTickAccess, pos, direction, neighborPos, neighborState, random);	11✔
165	}
166
167	@Override
168	public BlockState getStateForPlacement(BlockPlaceContext context) {
169	FluidState ifluidstate = context.getLevel().getFluidState(context.getClickedPos());	6✔
170	return this.defaultBlockState().setValue(WATERLOGGED, ifluidstate.getType() == Fluids.WATER);	12!
171	}
172
173	@Override
174	public FluidState getFluidState(BlockState state) {
175	return state.getValue(WATERLOGGED) ? Fluids.WATER.getSource(false) : super.getFluidState(state);	14✔
176	}
177
178	@Override
179	public boolean canPlaceLiquid(@org.jetbrains.annotations.Nullable LivingEntity entity, BlockGetter worldIn, BlockPos pos, BlockState blockState, Fluid fluidIn) {
180	return !blockState.getValue(BlockStateProperties.WATERLOGGED) && fluidIn == Fluids.WATER	×
181	&& !(worldIn instanceof ILevelExtension levelExtension && CableHelpers.hasFacade(levelExtension, pos, blockState));	×
182	}
183
184	@Override
185	public void onBlockExploded(BlockState state, ServerLevel world, BlockPos blockPos, Explosion explosion) {
186	CableHelpers.setRemovingCable(true);	2✔
187	CableHelpers.onCableRemoving(world, blockPos, true, false, state, world.getBlockEntity(blockPos));	10✔
188	super.onBlockExploded(state, world, blockPos, explosion);	6✔
189	CableHelpers.onCableRemoved(world, blockPos);	4✔
190	CableHelpers.setRemovingCable(false);	2✔
191	}	1✔
192
193	@Override
194	public boolean onDestroyedByPlayer(BlockState state, Level world, BlockPos pos, Player player, ItemStack toolStack, boolean willHarvest, FluidState fluid) {
195	BlockRayTraceResultComponent rayTraceResult = getSelectedShape(state, world, pos, CollisionContext.of(player))	9✔
196	.rayTrace(pos, player);	2✔
197	if (rayTraceResult != null && rayTraceResult.getComponent().destroy(world, pos, player, false)) {	10!
198	return false;	2✔
199	}
200	return rayTraceResult != null && super.onDestroyedByPlayer(state, world, pos, player, toolStack, willHarvest, fluid);	14!
201	}
202
203	@Override
204	protected void affectNeighborsAfterRemoval(BlockState state, ServerLevel level, BlockPos pos, boolean movedByPiston) {
205	super.affectNeighborsAfterRemoval(state, level, pos, movedByPiston);	6✔
206
207	if (!CableHelpers.isRemovingCable() && !SKIP_NETWORK_INIT) {	4!
208	CableHelpers.onCableRemoved(level, pos);	4✔
209	}
210	}	1✔
211
212	@Override
213	protected InteractionResult useItemOn(ItemStack pStack, BlockState pState, Level pLevel, BlockPos pPos, Player pPlayer, InteractionHand pHand, BlockHitResult pHitResult) {
214	/*
215	Wrench: sneak + right-click anywhere on cable to remove cable
216	right-click on a cable side to disconnect on that side
217	sneak + right-click on part to remove that part
218	No wrench: right-click to open GUI
219	*/
220	BlockEntityMultipartTicking tile = IModHelpers.get().getBlockEntityHelpers().get(pLevel, pPos, BlockEntityMultipartTicking.class).orElse(null);	10✔
221	if(tile != null) {	2!
222	BlockRayTraceResultComponent rayTraceResult = getSelectedShape(pState, pLevel, pPos, CollisionContext.of(pPlayer))	9✔
223	.rayTrace(pPos, pPlayer);	2✔
224	if(rayTraceResult != null) {	2!
225	InteractionResult actionResultType = rayTraceResult.getComponent().onBlockActivated(pState, pLevel, pPos, pPlayer, pHand, rayTraceResult);	10✔
226	if (actionResultType.consumesAction()) {	3!
227	return actionResultType;	2✔
228	}
229	}
230	}
231	return super.useItemOn(pStack, pState, pLevel, pPos, pPlayer, pHand, pHitResult);	×
232	}
233
234	@Override
235	public void onPlace(BlockState state, Level world, BlockPos pos, BlockState oldState, boolean isMoving) {
236	super.onPlace(state, world, pos, oldState, isMoving);	7✔
237	if (!world.isClientSide() && !SKIP_NETWORK_INIT) {	5!
238	ICableFakeable cableFakeable = CableHelpers.getCableFakeable(world, pos, null).orElse(null);	8✔
239	if (cableFakeable != null && cableFakeable.isRealCable()) {	5!
240	CableHelpers.onCableAdded(world, pos);	3✔
241	}
242	}
243	}	1✔
244
245	@Override
246	public void setPlacedBy(Level world, BlockPos pos, BlockState state, LivingEntity placer, ItemStack itemStack) {
247	super.setPlacedBy(world, pos, state, placer, itemStack);	7✔
248	if (!world.isClientSide()) {	3!
249	CableHelpers.onCableAddedByPlayer(world, pos, placer);	4✔
250	}
251	}	1✔
252
253	@Override
254	public ItemStack getCloneItemStack(LevelReader level, BlockPos pos, BlockState state, boolean includeData, Player player) {
255	BlockRayTraceResultComponent rayTraceResult = getSelectedShape(state, level, pos, CollisionContext.of(player))	×
256	.rayTrace(pos, player);	×
257	if(rayTraceResult != null && level instanceof Level levelReal) {	×
258	return rayTraceResult.getComponent().getCloneItemStack(levelReal, pos);	×
259	}
260	return super.getCloneItemStack(level, pos, state, includeData, player);	×
261	}
262
263	@Override
264	protected void neighborChanged(BlockState state, Level level, BlockPos pos, Block neighborBlock, @org.jetbrains.annotations.Nullable Orientation orientation, boolean movedByPiston) {
265	super.neighborChanged(state, level, pos, neighborBlock, orientation, movedByPiston);	8✔
266	NetworkHelpers.onElementProviderBlockNeighborChange(level, pos, orientation != null ? orientation.getFront().getOpposite() : null);	6!
267	}	1✔
268
269	@Override
270	public void onNeighborChange(BlockState state, LevelReader world, BlockPos pos, BlockPos neighbor) {
271	super.onNeighborChange(state, world, pos, neighbor);	6✔
272	if (world instanceof Level level) {	6!
273	NetworkHelpers.onElementProviderBlockNeighborChange(level, pos, null);	4✔
274	}
275	}	1✔
276
277	@Override
278	public void tick(BlockState state, ServerLevel world, BlockPos pos, RandomSource rand) {
279	super.tick(state, world, pos, rand);	×
280	IModHelpers.get().getBlockEntityHelpers().get(world, pos, BlockEntityMultipartTicking.class)	×
281	.ifPresent(tile -> {	×
282	for (Map.Entry<Direction, PartHelpers.PartStateHolder<?, ?>> entry : tile	×
283	.getPartContainer().getPartData().entrySet()) {	×
284	updateTickPart(entry.getValue().getPart(), world, pos, entry.getValue().getState(), rand);	×
285	}	×
286	});	×
287	}	×
288
289	protected void updateTickPart(IPartType partType, Level world, BlockPos pos, IPartState partState, RandomSource random) {
290	partType.updateTick(world, pos, partState, random);	×
291	}	×
292
293	/* --------------- Start shapes and rendering --------------- */
294
295	public AABB getCableBoundingBox(Direction side) {
296	if (side == null) {	×
297	return CABLE_CENTER_BOUNDINGBOX;	×
298	} else {
299	return CABLE_SIDE_BOUNDINGBOXES.get(side);	×
300	}
301	}
302
303	public VoxelShapeComponents getSelectedShape(BlockState blockState, BlockGetter world, BlockPos pos, CollisionContext selectionContext) {
304	return voxelShapeComponentsFactory.createShape(blockState, world, pos, selectionContext);	8✔
305	}
306
307	private final Cache<String, VoxelShape> CACHE_COLLISION_SHAPES = CacheBuilder.newBuilder()	4✔
308	.expireAfterAccess(1, TimeUnit.MINUTES)	1✔
309	.build();	2✔
310
311	@Override
312	public VoxelShape getShape(BlockState state, BlockGetter world, BlockPos pos, CollisionContext selectionContext) {
313	VoxelShapeComponents selectedShape = getSelectedShape(state, world, pos, selectionContext);	7✔
314	BlockRayTraceResultComponent rayTraceResult = selectedShape.rayTrace(pos, selectionContext instanceof EntityCollisionContext ? ((EntityCollisionContext) selectionContext).getEntity() : null);	11!
315	if (rayTraceResult != null) {	2!
316	return rayTraceResult.getComponent().getShape(state, world, pos, selectionContext);	×
317	}
318
319	String cableState = selectedShape.getStateId();	3✔
320
321	// Cache the operations below, as they are too expensive to execute each render tick
322	try {
323	return CACHE_COLLISION_SHAPES.get(cableState, () -> {	8✔
324	// Combine all VoxelShapes using IBooleanFunction.OR,
325	// because for some reason our VoxelShapeComponents aggregator does not handle collisions properly.
326	// This can probably be fixed, but I spent too much time on this already, and the current solution works just fine.
327	Iterator<VoxelShape> it = selectedShape.iterator();	3✔
328	if (!it.hasNext()) {	3✔
329	return Shapes.empty();	2✔
330	}
331	VoxelShape shape = it.next();	4✔
332	while (it.hasNext()) {	3✔
333	shape = Shapes.join(shape, it.next(), BooleanOp.OR);	8✔
334	}
335	return shape.optimize();	3✔
336	});
337	} catch (Exception e) {	×
338	return Helpers.sneakyThrow(e);	×
339	}
340	}
341
342	@Override
343	public VoxelShape getCollisionShape(BlockState blockState, BlockGetter world, BlockPos pos, CollisionContext selectionContext) {
344	return (disableCollisionBox \|\| GeneralConfig.disableCableCollision) ? Shapes.empty() : super.getCollisionShape(blockState, world, pos, selectionContext);	12!
345	}
346
347	@Override
348	public boolean hasDynamicShape() {
349	return BlockCableConfig.dynamicShape;	2✔
350	}
351
352	@Override
353	public RenderShape getRenderShape(BlockState blockState) {
354	return RenderShape.MODEL;	×
355	}
356
357	@Override
358	protected VoxelShape getBlockSupportShape(BlockState pState, BlockGetter pLevel, BlockPos pPos) {
359	return this.getShape(pState, pLevel, pPos, new CollisionContextBlockSupport());	9✔
360	}
361
362	@Override
363	public boolean shouldDisplayFluidOverlay(BlockState state, BlockAndLightGetter level, BlockPos pos, FluidState fluidState) {
364	return level instanceof RenderSectionRegion renderSectionRegion && CableHelpers.getFacade(renderSectionRegion.level, pos, state).isPresent();	×
365	}
366
367	/* --------------- Start IDynamicRedstone --------------- */
368
369	@SuppressWarnings("deprecation")
370	@Override
371	public boolean isSignalSource(BlockState blockState) {
372	return true;	×
373	}
374
375	@Override
376	public boolean canConnectRedstone(BlockState blockState, BlockGetter world, BlockPos pos, Direction side) {
377	if (world instanceof ILevelExtension levelExtension) {	6!
378	if (side == null) {	2!
379	for (Direction dummySide : Direction.values()) {	×
380	IDynamicRedstone dynamicRedstone = IModHelpersNeoForge.get().getCapabilityHelpers().getCapability(levelExtension, pos, dummySide, Capabilities.DynamicRedstone.BLOCK).orElse(null);	×
381	if (dynamicRedstone != null && (dynamicRedstone.getRedstoneLevel() >= 0 \|\| dynamicRedstone.isAllowRedstoneInput())) {	×
382	return true;	×
383	}
384	}
385	return false;	×
386	}
387	IDynamicRedstone dynamicRedstone = IModHelpersNeoForge.get().getCapabilityHelpers().getCapability(levelExtension, pos, side.getOpposite(), Capabilities.DynamicRedstone.BLOCK).orElse(null);	12✔
388	return dynamicRedstone != null && (dynamicRedstone.getRedstoneLevel() >= 0 \|\| dynamicRedstone.isAllowRedstoneInput());	12!
389	}
390	return false;	×
391	}
392
393	@SuppressWarnings("deprecation")
394	@Override
395	public int getDirectSignal(BlockState blockState, BlockGetter world, BlockPos pos, Direction side) {
396	if (world instanceof ILevelExtension levelExtension) {	6!
397	IDynamicRedstone dynamicRedstone = IModHelpersNeoForge.get().getCapabilityHelpers().getCapability(levelExtension, pos, side.getOpposite(), Capabilities.DynamicRedstone.BLOCK).orElse(null);	12✔
398	return dynamicRedstone != null && dynamicRedstone.isDirect() ? dynamicRedstone.getRedstoneLevel() : 0;	7!
399	}
400	return 0;	×
401	}
402
403	@SuppressWarnings("deprecation")
404	@Override
405	public int getSignal(BlockState blockState, BlockGetter world, BlockPos pos, Direction side) {
406	if (world instanceof ILevelExtension levelExtension) {	6!
407	IDynamicRedstone dynamicRedstone = IModHelpersNeoForge.get().getCapabilityHelpers().getCapability(levelExtension, pos, side.getOpposite(), Capabilities.DynamicRedstone.BLOCK).orElse(null);	12✔
408	return dynamicRedstone != null ? dynamicRedstone.getRedstoneLevel() : 0;	6!
409	}
410	return 0;	×
411	}
412
413	/* --------------- Start IDynamicLight --------------- */
414
415	@Override
416	public int getLightEmission(BlockState blockState, BlockGetter world, BlockPos pos) {
417	int light = 0;	2✔
418	if (world instanceof ILevelExtension levelExtension) {	6✔
419	for (Direction side : Direction.values()) {	16✔
420	IDynamicLight dynamicLight = levelExtension.getCapability(Capabilities.DynamicLight.BLOCK, pos, blockState, null, side);	9✔
421	if (dynamicLight != null) {	2!
422	light = Math.max(light, dynamicLight.getLightLevel());	×
423	}
424	}
425	}
426	return light;	2✔
427	}
428
429	}

CyclopsMC / IntegratedDynamics / 24201752325

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