13739195914

Committed 08 Mar 2025 03:58PM UTC coverage: 39.059% (+0.06%) from 39.002%

Build # 13739195914

Build Type

push

github

Committed by

rubensworks

Commit Message

Merge remote-tracking branch 'origin/master-1.21-lts' into master-1.21

Run Details

1966 of 8373 branches covered (23.48%)

Branch coverage included in aggregate %.

10307 of 23049 relevant lines covered (44.72%)

2.1 hits per line

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

75.0

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

package org.cyclops.integrateddynamics.core.blockentity;

import net.minecraft.core.BlockPos;
import net.minecraft.core.HolderLookup;
import net.minecraft.nbt.CompoundTag;
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.neoforged.neoforge.items.wrapper.InvWrapper;
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.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.ItemHandler.BLOCK,
                    (blockEntity, context) -> new InvWrapper(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(CompoundTag tag, HolderLookup.Provider provider) {
        super.read(tag, provider);
        connected.clear();
        inventory.readFromNBT(provider, tag, "inventory");
    }

    @Override
    public void saveAdditional(CompoundTag tag, HolderLookup.Provider provider) {
        inventory.writeToNBT(provider, tag, "inventory");
        super.saveAdditional(tag, provider);
    }

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

    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();
            }
            NetworkHelpers.revalidateNetworkElements(level, pos);
        }
    }

}

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

CyclopsMC / IntegratedDynamics / 13739195914

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