20210191346

Committed 14 Dec 2025 03:32PM UTC coverage: 19.514% (-33.5%) from 53.061%

Build # 20210191346

Build Type

push

github

Committed by

rubensworks

Commit Message

Remove deprecations

Run Details

663 of 8728 branches covered (7.6%)

Branch coverage included in aggregate %.

6786 of 29445 relevant lines covered (23.05%)

1.09 hits per line

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

11.43

/src/main/java/org/cyclops/integrateddynamics/core/blockentity/BlockEntityCableConnectableInventory.java

package org.cyclops.integrateddynamics.core.blockentity;

import net.minecraft.core.BlockPos;
import net.minecraft.world.Containers;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.block.entity.BlockEntityType;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.storage.ValueInput;
import net.minecraft.world.level.storage.ValueOutput;
import net.neoforged.neoforge.transfer.item.VanillaContainerWrapper;
import org.cyclops.cyclopscore.blockentity.BlockEntityTickerDelayed;
import org.cyclops.cyclopscore.blockentity.CyclopsBlockEntity;
import org.cyclops.cyclopscore.capability.registrar.BlockEntityCapabilityRegistrar;
import org.cyclops.cyclopscore.datastructure.EnumFacingMap;
import org.cyclops.cyclopscore.inventory.SimpleInventory;
import org.cyclops.cyclopscore.inventory.SimpleInventoryState;
import org.cyclops.cyclopscore.persist.nbt.NBTPersist;
import org.cyclops.integrateddynamics.Capabilities;
import org.cyclops.integrateddynamics.api.block.cable.ICable;
import org.cyclops.integrateddynamics.api.network.INetwork;
import org.cyclops.integrateddynamics.api.network.INetworkCarrier;
import org.cyclops.integrateddynamics.api.network.INetworkElementProvider;
import org.cyclops.integrateddynamics.capability.cable.CableTile;
import org.cyclops.integrateddynamics.capability.network.NetworkCarrierDefault;
import org.cyclops.integrateddynamics.capability.path.PathElementTile;
import org.cyclops.integrateddynamics.core.helper.CableHelpers;
import org.cyclops.integrateddynamics.core.helper.NetworkHelpers;

import javax.annotation.Nullable;
import java.util.function.Supplier;

/**
 * A part entity with inventory whose block can connect with cables.
 * @author rubensworks
 */
public abstract class BlockEntityCableConnectableInventory extends CyclopsBlockEntity {

    @NBTPersist
    private EnumFacingMap<Boolean> connected = EnumFacingMap.newMap();

    private final ICable cable;
    private final INetworkCarrier networkCarrier;
    private final SimpleInventory inventory;

    public BlockEntityCableConnectableInventory(BlockEntityType<?> type, BlockPos blockPos, BlockState blockState, int inventorySize, int stackSize) {
        super(type, blockPos, blockState);
        inventory = createInventory(inventorySize, stackSize);
        cable = new CableTile<BlockEntityCableConnectableInventory>(this) {

            @Override
            protected boolean isForceDisconnectable() {
                return false;
            }

            @Override
            protected EnumFacingMap<Boolean> getForceDisconnected() {
                return null;
            }

            @Override
            protected EnumFacingMap<Boolean> getConnected() {
                return tile.connected;
            }
        };
        networkCarrier = new NetworkCarrierDefault();
    }

    public static class CapabilityRegistrar<T extends BlockEntityCableConnectableInventory> extends BlockEntityCapabilityRegistrar<T> {
        public CapabilityRegistrar(Supplier<BlockEntityType<? extends T>> blockEntityType) {
            super(blockEntityType);
        }

        @Override
        public void populate() {
            add(
                    Capabilities.Cable.BLOCK,
                    (blockEntity, context) -> blockEntity.getCable()
            );
            add(
                    Capabilities.NetworkCarrier.BLOCK,
                    (blockEntity, context) -> blockEntity.getNetworkCarrier()
            );
            add(
                    Capabilities.PathElement.BLOCK,
                    (blockEntity, context) -> new PathElementTile<>(blockEntity, blockEntity.getCable())
            );
            add(
                    net.neoforged.neoforge.capabilities.Capabilities.Item.BLOCK,
                    (blockEntity, context) -> VanillaContainerWrapper.of(blockEntity.getInventory())
            );
            add(
                    org.cyclops.commoncapabilities.api.capability.Capabilities.InventoryState.BLOCK,
                    (blockEntity, context) -> new SimpleInventoryState(blockEntity.getInventory())
            );
        }
    }

    public EnumFacingMap<Boolean> getConnected() {
        return connected;
    }

    public ICable getCable() {
        return cable;
    }

    public INetworkCarrier getNetworkCarrier() {
        return networkCarrier;
    }

    public abstract INetworkElementProvider getNetworkElementProvider();

    protected SimpleInventory createInventory(int inventorySize, int stackSize) {
        return new SimpleInventory(inventorySize, stackSize) {
            @Override
            public boolean stillValid(Player entityplayer) {
                return level.getBlockEntity(worldPosition) == BlockEntityCableConnectableInventory.this;
            }
        };
    }


    @Override
    public void read(ValueInput input) {
        super.read(input);
        connected.clear();
        inventory.readFromNBT(input, "inventory");
    }

    @Override
    public void saveAdditional(ValueOutput output) {
        inventory.writeToNBT(output, "inventory");
        super.saveAdditional(output);
    }

    /**
     * Called after the network has been fully initialized
     */
    public void afterNetworkReAlive() {

    }

    @Nullable
    public INetwork getNetwork() {
        return this.networkCarrier.getNetwork();
    }

    public SimpleInventory getInventory() {
        return inventory;
    }

    @Override
    public void onChunkUnloaded() {
        super.onChunkUnloaded();
        if (getLevel() != null && !getLevel().isClientSide()) {
            INetwork network = getNetworkCarrier().getNetwork();
            if (network != null) {
                NetworkHelpers.invalidateNetworkElements(getLevel(), getBlockPos(), network, getNetworkElementProvider());
            }
        }
    }

    @Override
    public void preRemoveSideEffects(BlockPos pos, BlockState state) {
        super.preRemoveSideEffects(pos, state);

        Containers.dropContents(level, pos, this.getInventory());
        if (!CableHelpers.isRemovingCable()) {
            CableHelpers.onCableRemoving(level, pos, false, false, state, this);
        }
    }

    public static class Ticker<T extends BlockEntityCableConnectableInventory> extends BlockEntityTickerDelayed<T> {
        @Override
        protected void update(Level level, BlockPos pos, BlockState blockState, T blockEntity) {
            super.update(level, pos, blockState, blockEntity);

            if (blockEntity.getConnected().isEmpty()) {
                blockEntity.getCable().updateConnections();
            }
            if (NetworkHelpers.revalidateNetworkElements(level, pos)) {
                blockEntity.afterNetworkReAlive();
            }
        }
    }

}

1	package org.cyclops.integrateddynamics.core.blockentity;
2
3	import net.minecraft.core.BlockPos;
4	import net.minecraft.world.Containers;
5	import net.minecraft.world.entity.player.Player;
6	import net.minecraft.world.level.Level;
7	import net.minecraft.world.level.block.entity.BlockEntityType;
8	import net.minecraft.world.level.block.state.BlockState;
9	import net.minecraft.world.level.storage.ValueInput;
10	import net.minecraft.world.level.storage.ValueOutput;
11	import net.neoforged.neoforge.transfer.item.VanillaContainerWrapper;
12	import org.cyclops.cyclopscore.blockentity.BlockEntityTickerDelayed;
13	import org.cyclops.cyclopscore.blockentity.CyclopsBlockEntity;
14	import org.cyclops.cyclopscore.capability.registrar.BlockEntityCapabilityRegistrar;
15	import org.cyclops.cyclopscore.datastructure.EnumFacingMap;
16	import org.cyclops.cyclopscore.inventory.SimpleInventory;
17	import org.cyclops.cyclopscore.inventory.SimpleInventoryState;
18	import org.cyclops.cyclopscore.persist.nbt.NBTPersist;
19	import org.cyclops.integrateddynamics.Capabilities;
20	import org.cyclops.integrateddynamics.api.block.cable.ICable;
21	import org.cyclops.integrateddynamics.api.network.INetwork;
22	import org.cyclops.integrateddynamics.api.network.INetworkCarrier;
23	import org.cyclops.integrateddynamics.api.network.INetworkElementProvider;
24	import org.cyclops.integrateddynamics.capability.cable.CableTile;
25	import org.cyclops.integrateddynamics.capability.network.NetworkCarrierDefault;
26	import org.cyclops.integrateddynamics.capability.path.PathElementTile;
27	import org.cyclops.integrateddynamics.core.helper.CableHelpers;
28	import org.cyclops.integrateddynamics.core.helper.NetworkHelpers;
29
30	import javax.annotation.Nullable;
31	import java.util.function.Supplier;
32
33	/**
34	* A part entity with inventory whose block can connect with cables.
35	* @author rubensworks
36	*/
37	public abstract class BlockEntityCableConnectableInventory extends CyclopsBlockEntity {
38
39	@NBTPersist	×
40	private EnumFacingMap<Boolean> connected = EnumFacingMap.newMap();	×
41
42	private final ICable cable;
43	private final INetworkCarrier networkCarrier;
44	private final SimpleInventory inventory;
45
46	public BlockEntityCableConnectableInventory(BlockEntityType<?> type, BlockPos blockPos, BlockState blockState, int inventorySize, int stackSize) {
47	super(type, blockPos, blockState);	×
48	inventory = createInventory(inventorySize, stackSize);	×
49	cable = new CableTile<BlockEntityCableConnectableInventory>(this) {	×
50
51	@Override
52	protected boolean isForceDisconnectable() {
53	return false;	×
54	}
55
56	@Override
57	protected EnumFacingMap<Boolean> getForceDisconnected() {
58	return null;	×
59	}
60
61	@Override
62	protected EnumFacingMap<Boolean> getConnected() {
63	return tile.connected;	×
64	}
65	};
66	networkCarrier = new NetworkCarrierDefault();	×
67	}	×
68
69	public static class CapabilityRegistrar<T extends BlockEntityCableConnectableInventory> extends BlockEntityCapabilityRegistrar<T> {
70	public CapabilityRegistrar(Supplier<BlockEntityType<? extends T>> blockEntityType) {
71	super(blockEntityType);	3✔
72	}	1✔
73
74	@Override
75	public void populate() {
76	add(	4✔
77	Capabilities.Cable.BLOCK,
78	(blockEntity, context) -> blockEntity.getCable()	×
79	);
80	add(	4✔
81	Capabilities.NetworkCarrier.BLOCK,
82	(blockEntity, context) -> blockEntity.getNetworkCarrier()	×
83	);
84	add(	4✔
85	Capabilities.PathElement.BLOCK,
86	(blockEntity, context) -> new PathElementTile<>(blockEntity, blockEntity.getCable())	×
87	);
88	add(	4✔
89	net.neoforged.neoforge.capabilities.Capabilities.Item.BLOCK,
90	(blockEntity, context) -> VanillaContainerWrapper.of(blockEntity.getInventory())	×
91	);
92	add(	4✔
93	org.cyclops.commoncapabilities.api.capability.Capabilities.InventoryState.BLOCK,
94	(blockEntity, context) -> new SimpleInventoryState(blockEntity.getInventory())	×
95	);
96	}	1✔
97	}
98
99	public EnumFacingMap<Boolean> getConnected() {
100	return connected;	×
101	}
102
103	public ICable getCable() {
104	return cable;	×
105	}
106
107	public INetworkCarrier getNetworkCarrier() {
108	return networkCarrier;	×
109	}
110
111	public abstract INetworkElementProvider getNetworkElementProvider();
112
113	protected SimpleInventory createInventory(int inventorySize, int stackSize) {
114	return new SimpleInventory(inventorySize, stackSize) {	×
115	@Override
116	public boolean stillValid(Player entityplayer) {
117	return level.getBlockEntity(worldPosition) == BlockEntityCableConnectableInventory.this;	×
118	}
119	};
120	}
121
122
123	@Override
124	public void read(ValueInput input) {
125	super.read(input);	×
126	connected.clear();	×
127	inventory.readFromNBT(input, "inventory");	×
128	}	×
129
130	@Override
131	public void saveAdditional(ValueOutput output) {
132	inventory.writeToNBT(output, "inventory");	×
133	super.saveAdditional(output);	×
134	}	×
135
136	/**
137	* Called after the network has been fully initialized
138	*/
139	public void afterNetworkReAlive() {
140
141	}	×
142
143	@Nullable
144	public INetwork getNetwork() {
145	return this.networkCarrier.getNetwork();	×
146	}
147
148	public SimpleInventory getInventory() {
149	return inventory;	×
150	}
151
152	@Override
153	public void onChunkUnloaded() {
154	super.onChunkUnloaded();	×
155	if (getLevel() != null && !getLevel().isClientSide()) {	×
156	INetwork network = getNetworkCarrier().getNetwork();	×
157	if (network != null) {	×
158	NetworkHelpers.invalidateNetworkElements(getLevel(), getBlockPos(), network, getNetworkElementProvider());	×
159	}
160	}
161	}	×
162
163	@Override
164	public void preRemoveSideEffects(BlockPos pos, BlockState state) {
165	super.preRemoveSideEffects(pos, state);	×
166
167	Containers.dropContents(level, pos, this.getInventory());	×
168	if (!CableHelpers.isRemovingCable()) {	×
169	CableHelpers.onCableRemoving(level, pos, false, false, state, this);	×
170	}
171	}	×
172
173	public static class Ticker<T extends BlockEntityCableConnectableInventory> extends BlockEntityTickerDelayed<T> {	×
174	@Override
175	protected void update(Level level, BlockPos pos, BlockState blockState, T blockEntity) {
176	super.update(level, pos, blockState, blockEntity);	×
177
178	if (blockEntity.getConnected().isEmpty()) {	×
179	blockEntity.getCable().updateConnections();	×
180	}
181	if (NetworkHelpers.revalidateNetworkElements(level, pos)) {	×
182	blockEntity.afterNetworkReAlive();	×
183	}
184	}	×
185	}
186
187	}

CyclopsMC / IntegratedDynamics / 20210191346

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