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.29

/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.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 net.minecraft.world.level.storage.ValueInput;
import net.neoforged.neoforge.transfer.item.VanillaContainerWrapper;
import org.cyclops.cyclopscore.datastructure.DimPos;
import org.cyclops.cyclopscore.helper.IModHelpers;
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.Item.BLOCK,
                    (blockEntity, context) -> VanillaContainerWrapper.of(blockEntity.getInventory())
            );
            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(ValueInput input) {
        super.read(input);
        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(!IModHelpers.get().getMinecraftHelpers().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.network.chat.Component;
6	import net.minecraft.world.MenuProvider;
7	import net.minecraft.world.entity.player.Inventory;
8	import net.minecraft.world.entity.player.Player;
9	import net.minecraft.world.inventory.AbstractContainerMenu;
10	import net.minecraft.world.item.ItemStack;
11	import net.minecraft.world.level.Level;
12	import net.minecraft.world.level.block.entity.BlockEntityType;
13	import net.minecraft.world.level.block.state.BlockState;
14	import net.minecraft.world.level.storage.ValueInput;
15	import net.neoforged.neoforge.transfer.item.VanillaContainerWrapper;
16	import org.cyclops.cyclopscore.datastructure.DimPos;
17	import org.cyclops.cyclopscore.helper.IModHelpers;
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;	×
54
55	public BlockEntityVariablestore(BlockPos blockPos, BlockState blockState) {
56	super(RegistryEntries.BLOCK_ENTITY_VARIABLE_STORE.get(), blockPos, blockState, BlockEntityVariablestore.INVENTORY_SIZE, 1);	×
57	getInventory().addDirtyMarkListener(this);	×
58	variableContainer = new VariableContainerDefault();	×
59	}	×
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.Item.BLOCK,
72	(blockEntity, context) -> VanillaContainerWrapper.of(blockEntity.getInventory())	×
73	);
74	add(	4✔
75	Capabilities.NetworkElementProvider.BLOCK,
76	(blockEntity, context) -> blockEntity.getNetworkElementProvider()	×
77	);
78	add(	4✔
79	Capabilities.VariableContainer.BLOCK,
80	(blockEntity, context) -> blockEntity.getVariableContainer()	×
81	);
82	}	1✔
83	}
84
85	@Override
86	public INetworkElementProvider getNetworkElementProvider() {
87	return new NetworkElementProviderSingleton() {	×
88	@Override
89	public INetworkElement createNetworkElement(Level world, BlockPos blockPos) {
90	return new VariablestoreNetworkElement(DimPos.of(world, blockPos));	×
91	}
92	};
93	}
94
95	@Override
96	protected SimpleInventory createInventory(int inventorySize, int stackSize) {
97	return new SimpleInventory(inventorySize, stackSize) {	×
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;	×
108	}
109
110	@Override
111	public void read(ValueInput input) {
112	super.read(input);	×
113	shouldSendUpdateEvent = true;	×
114	}	×
115
116	protected void refreshVariables(boolean sendVariablesUpdateEvent) {
117	variableContainer.refreshVariables(getNetwork(), getInventory(), sendVariablesUpdateEvent, ValueDeseralizationContext.of(getLevel()));	×
118	}	×
119
120	@Override
121	public void onDirty() {
122	if(!level.isClientSide()) {	×
123	refreshVariables(true);	×
124	}
125	}	×
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();	×
133	if(!IModHelpers.get().getMinecraftHelpers().isClientSide()) {	×
134	shouldSendUpdateEvent = true;	×
135	}
136	}	×
137
138	@Override
139	public boolean hasEventSubscriptions() {
140	return true;	×
141	}
142
143	@Override
144	public Set<Class<? extends INetworkEvent>> getSubscribedEvents() {
145	return Sets.<Class<? extends INetworkEvent>>newHashSet(VariableContentsUpdatedEvent.class);	×
146	}
147
148	@Override
149	public void onEvent(INetworkEvent event, VariablestoreNetworkElement networkElement) {
150	if(event instanceof VariableContentsUpdatedEvent) {	×
151	refreshVariables(false);	×
152	}
153	}	×
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> {	×
167	@Override
168	protected void update(Level level, BlockPos pos, BlockState blockState, BlockEntityVariablestore blockEntity) {
169	super.update(level, pos, blockState, blockEntity);	×
170
171	if (blockEntity.shouldSendUpdateEvent && blockEntity.getNetwork() != null) {	×
172	blockEntity.shouldSendUpdateEvent = false;	×
173	blockEntity.refreshVariables(true);	×
174	}
175	}	×
176	}
177	}

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