36319118540

Committed 27 Sep 2026 12:28PM UTC coverage: 48.259% (+0.2%) from 48.068%

Build # 36319118540

Build Type

Pull #1753

github

Committed by

web-flow

Commit Message

Merge 414d3da58 into 2af9e4141

Pull Request Pull Request #1753: Stop ticking cables without parts

Coverage Stats

3481 of 9861 branches covered (35.3%)

Branch coverage included in aggregate %.

13734 of 25811 relevant lines covered (53.21%)

2.55 hits per line

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

70.97

/src/main/java/org/cyclops/integrateddynamics/blockentity/BlockEntityVariablestore.java

package org.cyclops.integrateddynamics.blockentity;

import com.google.common.collect.Sets;
import net.minecraft.core.BlockPos;
import net.minecraft.core.HolderLookup;
import net.minecraft.nbt.CompoundTag;
import net.minecraft.network.chat.Component;
import net.minecraft.world.MenuProvider;
import net.minecraft.world.entity.player.Inventory;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.inventory.AbstractContainerMenu;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.block.entity.BlockEntityType;
import net.minecraft.world.level.block.state.BlockState;
import org.cyclops.cyclopscore.datastructure.DimPos;
import org.cyclops.cyclopscore.helper.MinecraftHelpers;
import org.cyclops.cyclopscore.inventory.SimpleInventory;
import org.cyclops.cyclopscore.persist.IDirtyMarkListener;
import org.cyclops.integrateddynamics.Capabilities;
import org.cyclops.integrateddynamics.RegistryEntries;
import org.cyclops.integrateddynamics.api.block.IVariableContainer;
import org.cyclops.integrateddynamics.api.evaluate.variable.ValueDeseralizationContext;
import org.cyclops.integrateddynamics.api.network.INetworkElement;
import org.cyclops.integrateddynamics.api.network.INetworkElementProvider;
import org.cyclops.integrateddynamics.api.network.INetworkEventListener;
import org.cyclops.integrateddynamics.api.network.event.INetworkEvent;
import org.cyclops.integrateddynamics.capability.networkelementprovider.NetworkElementProviderSingleton;
import org.cyclops.integrateddynamics.capability.variablecontainer.VariableContainerDefault;
import org.cyclops.integrateddynamics.core.blockentity.BlockEntityCableConnectableInventory;
import org.cyclops.integrateddynamics.core.network.event.VariableContentsUpdatedEvent;
import org.cyclops.integrateddynamics.inventory.container.ContainerVariablestore;
import org.cyclops.integrateddynamics.network.VariablestoreNetworkElement;

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

/**
 * A part entity used to store variables.
 * Internally, this also acts as an expression cache
 * @author rubensworks
 */
public class BlockEntityVariablestore extends BlockEntityCableConnectableInventory
        implements IDirtyMarkListener, INetworkEventListener<VariablestoreNetworkElement>, MenuProvider {

    public static final int ROWS = 5;
    public static final int COLS = 9;
    public static final int INVENTORY_SIZE = ROWS * COLS;

    private final IVariableContainer variableContainer;

    private boolean shouldSendUpdateEvent = false;

    public BlockEntityVariablestore(BlockPos blockPos, BlockState blockState) {
        super(RegistryEntries.BLOCK_ENTITY_VARIABLE_STORE.get(), blockPos, blockState, BlockEntityVariablestore.INVENTORY_SIZE, 1);
        getInventory().addDirtyMarkListener(this);
        variableContainer = new VariableContainerDefault();
    }

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

        @Override
        public void populate() {
            super.populate();

            add(
                    net.neoforged.neoforge.capabilities.Capabilities.ItemHandler.BLOCK,
                    (blockEntity, context) -> blockEntity.getInventory().getItemHandler()
            );
            add(
                    Capabilities.NetworkElementProvider.BLOCK,
                    (blockEntity, context) -> blockEntity.getNetworkElementProvider()
            );
            add(
                    Capabilities.VariableContainer.BLOCK,
                    (blockEntity, context) -> blockEntity.getVariableContainer()
            );
        }
    }

    @Override
    public INetworkElementProvider getNetworkElementProvider() {
        return new NetworkElementProviderSingleton() {
            @Override
            public INetworkElement createNetworkElement(Level world, BlockPos blockPos) {
                return new VariablestoreNetworkElement(DimPos.of(world, blockPos));
            }
        };
    }

    @Override
    protected SimpleInventory createInventory(int inventorySize, int stackSize) {
        return new SimpleInventory(inventorySize, stackSize) {
            @Override
            public boolean canPlaceItem(int slot, ItemStack itemStack) {
                return super.canPlaceItem(slot, itemStack)
                        && (itemStack.isEmpty() || itemStack.getCapability(Capabilities.VariableFacade.ITEM) != null);
            }
        };
    }

    public IVariableContainer getVariableContainer() {
        return variableContainer;
    }

    @Override
    public void read(CompoundTag tag, HolderLookup.Provider provider) {
        super.read(tag, provider);
        shouldSendUpdateEvent = true;
    }

    protected void refreshVariables(boolean sendVariablesUpdateEvent) {
        variableContainer.refreshVariables(getNetwork(), getInventory(), sendVariablesUpdateEvent, ValueDeseralizationContext.of(getLevel()));
    }

    @Override
    public void onDirty() {
        if(!level.isClientSide()) {
            refreshVariables(true);
        }
    }

    // Make sure that when this TE is loaded, and after the network has been set,
    // that we trigger a variable update event in the network.

    @Override
    public void onLoad() {
        super.onLoad();
        if(!MinecraftHelpers.isClientSide()) {
            shouldSendUpdateEvent = true;
        }
    }

    @Override
    public boolean hasEventSubscriptions() {
        return true;
    }

    @Override
    public Set<Class<? extends INetworkEvent>> getSubscribedEvents() {
        return Sets.<Class<? extends INetworkEvent>>newHashSet(VariableContentsUpdatedEvent.class);
    }

    @Override
    public void onEvent(INetworkEvent event, VariablestoreNetworkElement networkElement) {
        if(event instanceof VariableContentsUpdatedEvent) {
            refreshVariables(false);
        }
    }

    @Nullable
    @Override
    public AbstractContainerMenu createMenu(int id, Inventory playerInventory, Player playerEntity) {
        return new ContainerVariablestore(id, playerInventory, this.getInventory());
    }

    @Override
    public Component getDisplayName() {
        return Component.translatable("block.integrateddynamics.variablestore");
    }

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

            if (blockEntity.shouldSendUpdateEvent && blockEntity.getNetwork() != null) {
                blockEntity.shouldSendUpdateEvent = false;
                blockEntity.refreshVariables(true);
            }
        }
    }
}

1	package org.cyclops.integrateddynamics.blockentity;
2
3	import com.google.common.collect.Sets;
4	import net.minecraft.core.BlockPos;
5	import net.minecraft.core.HolderLookup;
6	import net.minecraft.nbt.CompoundTag;
7	import net.minecraft.network.chat.Component;
8	import net.minecraft.world.MenuProvider;
9	import net.minecraft.world.entity.player.Inventory;
10	import net.minecraft.world.entity.player.Player;
11	import net.minecraft.world.inventory.AbstractContainerMenu;
12	import net.minecraft.world.item.ItemStack;
13	import net.minecraft.world.level.Level;
14	import net.minecraft.world.level.block.entity.BlockEntityType;
15	import net.minecraft.world.level.block.state.BlockState;
16	import org.cyclops.cyclopscore.datastructure.DimPos;
17	import org.cyclops.cyclopscore.helper.MinecraftHelpers;
18	import org.cyclops.cyclopscore.inventory.SimpleInventory;
19	import org.cyclops.cyclopscore.persist.IDirtyMarkListener;
20	import org.cyclops.integrateddynamics.Capabilities;
21	import org.cyclops.integrateddynamics.RegistryEntries;
22	import org.cyclops.integrateddynamics.api.block.IVariableContainer;
23	import org.cyclops.integrateddynamics.api.evaluate.variable.ValueDeseralizationContext;
24	import org.cyclops.integrateddynamics.api.network.INetworkElement;
25	import org.cyclops.integrateddynamics.api.network.INetworkElementProvider;
26	import org.cyclops.integrateddynamics.api.network.INetworkEventListener;
27	import org.cyclops.integrateddynamics.api.network.event.INetworkEvent;
28	import org.cyclops.integrateddynamics.capability.networkelementprovider.NetworkElementProviderSingleton;
29	import org.cyclops.integrateddynamics.capability.variablecontainer.VariableContainerDefault;
30	import org.cyclops.integrateddynamics.core.blockentity.BlockEntityCableConnectableInventory;
31	import org.cyclops.integrateddynamics.core.network.event.VariableContentsUpdatedEvent;
32	import org.cyclops.integrateddynamics.inventory.container.ContainerVariablestore;
33	import org.cyclops.integrateddynamics.network.VariablestoreNetworkElement;
34
35	import javax.annotation.Nullable;
36	import java.util.Set;
37	import java.util.function.Supplier;
38
39	/**
40	* A part entity used to store variables.
41	* Internally, this also acts as an expression cache
42	* @author rubensworks
43	*/
44	public class BlockEntityVariablestore extends BlockEntityCableConnectableInventory
45	implements IDirtyMarkListener, INetworkEventListener<VariablestoreNetworkElement>, MenuProvider {
46
47	public static final int ROWS = 5;
48	public static final int COLS = 9;
49	public static final int INVENTORY_SIZE = ROWS * COLS;
50
51	private final IVariableContainer variableContainer;
52
53	private boolean shouldSendUpdateEvent = false;	3 ✔
54
55	public BlockEntityVariablestore(BlockPos blockPos, BlockState blockState) {
56	super(RegistryEntries.BLOCK_ENTITY_VARIABLE_STORE.get(), blockPos, blockState, BlockEntityVariablestore.INVENTORY_SIZE, 1);	9 ✔
57	getInventory().addDirtyMarkListener(this);	4 ✔
58	variableContainer = new VariableContainerDefault();	5 ✔
59	}	1 ✔
60
61	public static class CapabilityRegistrar extends BlockEntityCableConnectableInventory.CapabilityRegistrar<BlockEntityVariablestore> {
62	public CapabilityRegistrar(Supplier<BlockEntityType<? extends BlockEntityVariablestore>> blockEntityType) {
63	super(blockEntityType);	3 ✔
64	}	1 ✔
65
66	@Override
67	public void populate() {
68	super.populate();	2 ✔
69
70	add(	4 ✔
71	net.neoforged.neoforge.capabilities.Capabilities.ItemHandler.BLOCK,
72	(blockEntity, context) -> blockEntity.getInventory().getItemHandler()	×
73	);
74	add(	4 ✔
75	Capabilities.NetworkElementProvider.BLOCK,
76	(blockEntity, context) -> blockEntity.getNetworkElementProvider()	3 ✔
77	);
78	add(	4 ✔
79	Capabilities.VariableContainer.BLOCK,
80	(blockEntity, context) -> blockEntity.getVariableContainer()	3 ✔
81	);
82	}	1 ✔
83	}
84
85	@Override
86	public INetworkElementProvider getNetworkElementProvider() {
87	return new NetworkElementProviderSingleton() {	8 ✔
88	@Override
89	public INetworkElement createNetworkElement(Level world, BlockPos blockPos) {
90	return new VariablestoreNetworkElement(DimPos.of(world, blockPos));	7 ✔
91	}
92	};
93	}
94
95	@Override
96	protected SimpleInventory createInventory(int inventorySize, int stackSize) {
97	return new SimpleInventory(inventorySize, stackSize) {	12 ✔
98	@Override
99	public boolean canPlaceItem(int slot, ItemStack itemStack) {
100	return super.canPlaceItem(slot, itemStack)	×
101	&& (itemStack.isEmpty() \|\| itemStack.getCapability(Capabilities.VariableFacade.ITEM) != null);	×
102	}
103	};
104	}
105
106	public IVariableContainer getVariableContainer() {
107	return variableContainer;	3 ✔
108	}
109
110	@Override
111	public void read(CompoundTag tag, HolderLookup.Provider provider) {
112	super.read(tag, provider);	×
113	shouldSendUpdateEvent = true;	×
114	}	×
115
116	protected void refreshVariables(boolean sendVariablesUpdateEvent) {
117	variableContainer.refreshVariables(getNetwork(), getInventory(), sendVariablesUpdateEvent, ValueDeseralizationContext.of(getLevel()));	11 ✔
118	}	1 ✔
119
120	@Override
121	public void onDirty() {
122	if(!level.isClientSide()) {	4 !
123	refreshVariables(true);	3 ✔
124	}
125	}	1 ✔
126
127	// Make sure that when this TE is loaded, and after the network has been set,
128	// that we trigger a variable update event in the network.
129
130	@Override
131	public void onLoad() {
132	super.onLoad();	2 ✔
133	if(!MinecraftHelpers.isClientSide()) {	2 !
134	shouldSendUpdateEvent = true;	3 ✔
135	}
136	}	1 ✔
137
138	@Override
139	public boolean hasEventSubscriptions() {
140	return true;	2 ✔
141	}
142
143	@Override
144	public Set<Class<? extends INetworkEvent>> getSubscribedEvents() {
145	return Sets.<Class<? extends INetworkEvent>>newHashSet(VariableContentsUpdatedEvent.class);	8 ✔
146	}
147
148	@Override
149	public void onEvent(INetworkEvent event, VariablestoreNetworkElement networkElement) {
150	if(event instanceof VariableContentsUpdatedEvent) {	3 !
151	refreshVariables(false);	3 ✔
152	}
153	}	1 ✔
154
155	@Nullable
156	@Override
157	public AbstractContainerMenu createMenu(int id, Inventory playerInventory, Player playerEntity) {
158	return new ContainerVariablestore(id, playerInventory, this.getInventory());	×
159	}
160
161	@Override
162	public Component getDisplayName() {
163	return Component.translatable("block.integrateddynamics.variablestore");	×
164	}
165
166	public static class Ticker extends BlockEntityCableConnectableInventory.Ticker<BlockEntityVariablestore> {	3 ✔
167	@Override
168	protected void update(Level level, BlockPos pos, BlockState blockState, BlockEntityVariablestore blockEntity) {
169	super.update(level, pos, blockState, blockEntity);	6 ✔
170
171	if (blockEntity.shouldSendUpdateEvent && blockEntity.getNetwork() != null) {	6 !
172	blockEntity.shouldSendUpdateEvent = false;	3 ✔
173	blockEntity.refreshVariables(true);	3 ✔
174	}
175	}	1 ✔
176	}
177	}

CyclopsMC / IntegratedDynamics / 36319118540

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