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

6.71

/src/main/java/org/cyclops/integrateddynamics/core/part/write/PartTypeWriteBase.java

package org.cyclops.integrateddynamics.core.part.write;

import net.minecraft.ChatFormatting;
import net.minecraft.core.Direction;
import net.minecraft.core.Vec3i;
import net.minecraft.network.RegistryFriendlyByteBuf;
import net.minecraft.network.chat.Component;
import net.minecraft.server.level.ServerPlayer;
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.block.Block;
import net.minecraft.world.level.block.state.BlockBehaviour;
import net.minecraft.world.level.block.state.BlockState;
import net.neoforged.neoforge.common.NeoForge;
import org.apache.commons.lang3.tuple.Triple;
import org.cyclops.cyclopscore.config.extendedconfig.BlockConfigCommon;
import org.cyclops.cyclopscore.network.PacketCodecs;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValue;
import org.cyclops.integrateddynamics.api.evaluate.variable.IVariable;
import org.cyclops.integrateddynamics.api.evaluate.variable.ValueDeseralizationContext;
import org.cyclops.integrateddynamics.api.network.INetwork;
import org.cyclops.integrateddynamics.api.network.IPartNetwork;
import org.cyclops.integrateddynamics.api.network.event.INetworkEvent;
import org.cyclops.integrateddynamics.api.part.IPartContainer;
import org.cyclops.integrateddynamics.api.part.PartPos;
import org.cyclops.integrateddynamics.api.part.PartRenderPosition;
import org.cyclops.integrateddynamics.api.part.PartTarget;
import org.cyclops.integrateddynamics.api.part.aspect.IAspect;
import org.cyclops.integrateddynamics.api.part.aspect.IAspectWrite;
import org.cyclops.integrateddynamics.api.part.write.IPartStateWriter;
import org.cyclops.integrateddynamics.api.part.write.IPartTypeWriter;
import org.cyclops.integrateddynamics.core.block.IgnoredBlock;
import org.cyclops.integrateddynamics.core.block.IgnoredBlockStatus;
import org.cyclops.integrateddynamics.core.helper.L10NValues;
import org.cyclops.integrateddynamics.core.helper.NetworkHelpers;
import org.cyclops.integrateddynamics.core.helper.PartHelpers;
import org.cyclops.integrateddynamics.core.network.event.VariableContentsUpdatedEvent;
import org.cyclops.integrateddynamics.core.part.PartTypeAspects;
import org.cyclops.integrateddynamics.core.part.PartTypeBase;
import org.cyclops.integrateddynamics.core.part.event.PartWriterAspectEvent;
import org.cyclops.integrateddynamics.inventory.container.ContainerPartWriter;
import org.cyclops.integrateddynamics.part.aspect.Aspects;

import javax.annotation.Nullable;
import java.util.List;
import java.util.Map;
import java.util.Optional;

/**
 * An abstract {@link IPartTypeWriter}.
 * @author rubensworks
 */
public abstract class PartTypeWriteBase<P extends IPartTypeWriter<P, S>, S extends IPartStateWriter<P>>
        extends PartTypeAspects<P, S> implements IPartTypeWriter<P, S> {

    private List<IAspectWrite<?, ?>> aspectsWrite = null;

    public PartTypeWriteBase(String name) {
        this(name, new PartRenderPosition(0.3125F, 0.3125F, 0.625F, 0.625F, 0.25F, 0.25F));
    }

    public PartTypeWriteBase(String name, PartRenderPosition partRenderPosition) {
        super(name, partRenderPosition);
    }

    @Override
    protected Map<Class<? extends INetworkEvent>, IEventAction> constructNetworkEventActions() {
        Map<Class<? extends INetworkEvent>, IEventAction> actions = super.constructNetworkEventActions();
        IEventAction<P, S, INetworkEvent> updateEventListener = (network, target, state, event) -> NetworkHelpers
                .getPartNetwork(network).ifPresent(partNetwork -> onVariableContentsUpdated(partNetwork, target, state));
        actions.put(VariableContentsUpdatedEvent.class, updateEventListener);
        return actions;
    }

    @Override
    protected Block createBlock(BlockConfigCommon<?> blockConfig, BlockBehaviour.Properties properties) {
        return new IgnoredBlockStatus(properties);
    }

    @Override
    public void update(INetwork network, IPartNetwork partNetwork, PartTarget target, S state) {
        super.update(network, partNetwork, target, state);
        IAspect aspect = getActiveAspect(target, state);
        if (aspect != null) {
            aspect.update(network, partNetwork, this, target, state);
        }
    }

    @Override
    public boolean setTargetOffset(S state, PartPos center, Vec3i offset) {
        IAspectWrite activeAspect = state.getActiveAspect();
        if(activeAspect != null) {
            activeAspect.onDeactivate(this, getTarget(center, state), state);
        }
        boolean ret = super.setTargetOffset(state, center, offset);
        if(activeAspect != null) {
            activeAspect.onActivate(this, getTarget(center, state), state);
        }
        return ret;
    }

    @Override
    public void addDrops(PartTarget target, S state, List<ItemStack> itemStacks, boolean dropMainElement, boolean saveState) {
        for(int i = 0; i < state.getInventory().getContainerSize(); i++) {
            ItemStack itemStack = state.getInventory().getItem(i);
            if(!itemStack.isEmpty()) {
                itemStacks.add(itemStack);
            }
        }
        state.getInventory().clearContent();
        state.triggerAspectInfoUpdate((P) this, target, null, false);
        super.addDrops(target, state, itemStacks, dropMainElement, saveState);
    }

    @Override
    public void beforeNetworkKill(INetwork network, IPartNetwork partNetwork, PartTarget target, S state) {
        super.beforeNetworkKill(network, partNetwork, target, state);
        state.triggerAspectInfoUpdate((P) this, target, null, true);
    }

    @Override
    public void afterNetworkAlive(INetwork network, IPartNetwork partNetwork, PartTarget target, S state) {
        super.afterNetworkAlive(network, partNetwork, target, state);
        updateActivation(target, state, null, true);
    }

    @Override
    public List<IAspectWrite<?, ?>> getWriteAspects() {
        if (aspectsWrite == null) {
            aspectsWrite = Aspects.REGISTRY.getWriteAspects(this);
        }
        return aspectsWrite;
    }

    @Override
    public boolean hasActiveVariable(IPartNetwork network, PartTarget target, S partState) {
        return partState.hasVariable();
    }

    @Override
    public <V extends IValue> IVariable<V> getActiveVariable(INetwork network, IPartNetwork partNetwork, PartTarget target, S partState) {
        return partState.getVariable(network, partNetwork, ValueDeseralizationContext.of(target.getCenter().getPos().getLevel(true)));
    }

    @Override
    public IAspectWrite getActiveAspect(PartTarget target, S partState) {
        return partState.getActiveAspect();
    }

    @Override
    public void updateActivation(PartTarget target, S partState, @Nullable Player player, boolean isNetworkInitializing) {
        // Check inside the inventory for a variable item and determine everything with that.
        int activeIndex = -1;
        for(int i = 0 ; i < partState.getInventory().getContainerSize(); i++) {
            if(!partState.getInventory().getItem(i).isEmpty()) {
                activeIndex = i;
                break;
            }
        }
        IAspectWrite aspect = activeIndex == -1 ? null : getWriteAspects().get(activeIndex);
        partState.triggerAspectInfoUpdate((P) this, target, aspect, isNetworkInitializing);

        INetwork network = NetworkHelpers.getNetwork(target.getCenter()).orElse(null);
        if (network != null && aspect != null) {
            IPartNetwork partNetwork = NetworkHelpers.getPartNetwork(network).orElse(null);
            if (partNetwork != null) {
                NeoForge.EVENT_BUS.post(new PartWriterAspectEvent<>(network, partNetwork, target, (P) this,
                        partState, player, aspect, partState.getInventory().getItem(activeIndex)));
            }
        }
        if (network != null && !isNetworkInitializing) {
            network.getEventBus().post(new VariableContentsUpdatedEvent(network));
        }
    }

    protected void onVariableContentsUpdated(IPartNetwork network, PartTarget target, S state) {
        state.onVariableContentsUpdated((P) this, target);
    }

    protected IgnoredBlockStatus.Status getStatus(IPartStateWriter state) {
        IgnoredBlockStatus.Status status = IgnoredBlockStatus.Status.INACTIVE;
        if (state != null && !state.getInventory().isEmpty()) {
            if (state.hasVariable() && state.isEnabled()) {
                status = IgnoredBlockStatus.Status.ACTIVE;
            } else {
                status = IgnoredBlockStatus.Status.ERROR;
            }
        }
        return status;
    }

    @Override
    public BlockState getBlockState(IPartContainer partContainer,
                                    Direction side) {
        IgnoredBlockStatus.Status status = getStatus(partContainer != null
                ? (IPartStateWriter) partContainer.getPartState(side) : null);
        return getBlock().defaultBlockState().setValue(IgnoredBlock.FACING, side)
                .setValue(IgnoredBlockStatus.STATUS, status);
    }

    @Override
    public void loadTooltip(S state, List<Component> lines) {
        super.loadTooltip(state, lines);
        IAspectWrite aspectWrite = state.getActiveAspect();
        if (aspectWrite != null) {
            if (state.hasVariable() && state.isEnabled()) {
                lines.add(Component.translatable(
                        L10NValues.PART_TOOLTIP_WRITER_ACTIVEASPECT,
                        Component.translatable(aspectWrite.getTranslationKey()),
                        Component.translatable(aspectWrite.getValueType().getTranslationKey())
                                .withStyle(aspectWrite.getValueType().getDisplayColorFormat())));
            } else {
                lines.add(Component.translatable(L10NValues.PART_TOOLTIP_ERRORS)
                        .withStyle(ChatFormatting.RED));
                for (Component error : state.getErrors(aspectWrite)) {
                    lines.add(error.copy().withStyle(ChatFormatting.RED));
                }
            }
        } else {
            lines.add(Component.translatable(L10NValues.PART_TOOLTIP_INACTIVE));
        }
    }

    @Override
    public Optional<MenuProvider> getContainerProvider(PartPos pos) {
        return Optional.of(new MenuProvider() {
            @Override
            public Component getDisplayName() {
                return Component.translatable(getTranslationKey());
            }

            @Nullable
            @Override
            public AbstractContainerMenu createMenu(int id, Inventory playerInventory, Player playerEntity) {
                Triple<IPartContainer, PartTypeBase, PartTarget> data = PartHelpers.getContainerPartConstructionData(pos);
                S partState = (S) data.getLeft().getPartState(data.getRight().getCenter().getSide());
                return new ContainerPartWriter<>(id, playerInventory, partState.getInventory(),
                        data.getRight(), Optional.of(data.getLeft()), (PartTypeWriteBase) data.getMiddle());
            }

            @Override
            public boolean shouldTriggerClientSideContainerClosingOnOpen() {
                return false;
            }
        });
    }

    @Override
    public void writeExtraGuiData(RegistryFriendlyByteBuf packetBuffer, PartPos pos, ServerPlayer player) {
        // Write inventory size
        packetBuffer.writeInt(getWriteAspects().size());
        // Write part position
        PacketCodecs.write(packetBuffer, pos);

        super.writeExtraGuiData(packetBuffer, pos, player);
    }

    @Override
    public boolean shouldTriggerBlockRenderUpdate(@Nullable S oldPartState, @Nullable S newPartState) {
        return super.shouldTriggerBlockRenderUpdate(oldPartState, newPartState)
                || getStatus(oldPartState) != getStatus(newPartState);
    }

}

1	package org.cyclops.integrateddynamics.core.part.write;
2
3	import net.minecraft.ChatFormatting;
4	import net.minecraft.core.Direction;
5	import net.minecraft.core.Vec3i;
6	import net.minecraft.network.RegistryFriendlyByteBuf;
7	import net.minecraft.network.chat.Component;
8	import net.minecraft.server.level.ServerPlayer;
9	import net.minecraft.world.MenuProvider;
10	import net.minecraft.world.entity.player.Inventory;
11	import net.minecraft.world.entity.player.Player;
12	import net.minecraft.world.inventory.AbstractContainerMenu;
13	import net.minecraft.world.item.ItemStack;
14	import net.minecraft.world.level.block.Block;
15	import net.minecraft.world.level.block.state.BlockBehaviour;
16	import net.minecraft.world.level.block.state.BlockState;
17	import net.neoforged.neoforge.common.NeoForge;
18	import org.apache.commons.lang3.tuple.Triple;
19	import org.cyclops.cyclopscore.config.extendedconfig.BlockConfigCommon;
20	import org.cyclops.cyclopscore.network.PacketCodecs;
21	import org.cyclops.integrateddynamics.api.evaluate.variable.IValue;
22	import org.cyclops.integrateddynamics.api.evaluate.variable.IVariable;
23	import org.cyclops.integrateddynamics.api.evaluate.variable.ValueDeseralizationContext;
24	import org.cyclops.integrateddynamics.api.network.INetwork;
25	import org.cyclops.integrateddynamics.api.network.IPartNetwork;
26	import org.cyclops.integrateddynamics.api.network.event.INetworkEvent;
27	import org.cyclops.integrateddynamics.api.part.IPartContainer;
28	import org.cyclops.integrateddynamics.api.part.PartPos;
29	import org.cyclops.integrateddynamics.api.part.PartRenderPosition;
30	import org.cyclops.integrateddynamics.api.part.PartTarget;
31	import org.cyclops.integrateddynamics.api.part.aspect.IAspect;
32	import org.cyclops.integrateddynamics.api.part.aspect.IAspectWrite;
33	import org.cyclops.integrateddynamics.api.part.write.IPartStateWriter;
34	import org.cyclops.integrateddynamics.api.part.write.IPartTypeWriter;
35	import org.cyclops.integrateddynamics.core.block.IgnoredBlock;
36	import org.cyclops.integrateddynamics.core.block.IgnoredBlockStatus;
37	import org.cyclops.integrateddynamics.core.helper.L10NValues;
38	import org.cyclops.integrateddynamics.core.helper.NetworkHelpers;
39	import org.cyclops.integrateddynamics.core.helper.PartHelpers;
40	import org.cyclops.integrateddynamics.core.network.event.VariableContentsUpdatedEvent;
41	import org.cyclops.integrateddynamics.core.part.PartTypeAspects;
42	import org.cyclops.integrateddynamics.core.part.PartTypeBase;
43	import org.cyclops.integrateddynamics.core.part.event.PartWriterAspectEvent;
44	import org.cyclops.integrateddynamics.inventory.container.ContainerPartWriter;
45	import org.cyclops.integrateddynamics.part.aspect.Aspects;
46
47	import javax.annotation.Nullable;
48	import java.util.List;
49	import java.util.Map;
50	import java.util.Optional;
51
52	/**
53	* An abstract {@link IPartTypeWriter}.
54	* @author rubensworks
55	*/
56	public abstract class PartTypeWriteBase<P extends IPartTypeWriter<P, S>, S extends IPartStateWriter<P>>
57	extends PartTypeAspects<P, S> implements IPartTypeWriter<P, S> {
58
59	private List<IAspectWrite<?, ?>> aspectsWrite = null;	3✔
60
61	public PartTypeWriteBase(String name) {
62	this(name, new PartRenderPosition(0.3125F, 0.3125F, 0.625F, 0.625F, 0.25F, 0.25F));	12✔
63	}	1✔
64
65	public PartTypeWriteBase(String name, PartRenderPosition partRenderPosition) {
66	super(name, partRenderPosition);	4✔
67	}	1✔
68
69	@Override
70	protected Map<Class<? extends INetworkEvent>, IEventAction> constructNetworkEventActions() {
71	Map<Class<? extends INetworkEvent>, IEventAction> actions = super.constructNetworkEventActions();	3✔
72	IEventAction<P, S, INetworkEvent> updateEventListener = (network, target, state, event) -> NetworkHelpers	3✔
73	.getPartNetwork(network).ifPresent(partNetwork -> onVariableContentsUpdated(partNetwork, target, state));	×
74	actions.put(VariableContentsUpdatedEvent.class, updateEventListener);	5✔
75	return actions;	2✔
76	}
77
78	@Override
79	protected Block createBlock(BlockConfigCommon<?> blockConfig, BlockBehaviour.Properties properties) {
80	return new IgnoredBlockStatus(properties);	5✔
81	}
82
83	@Override
84	public void update(INetwork network, IPartNetwork partNetwork, PartTarget target, S state) {
85	super.update(network, partNetwork, target, state);	×
86	IAspect aspect = getActiveAspect(target, state);	×
87	if (aspect != null) {	×
88	aspect.update(network, partNetwork, this, target, state);	×
89	}
90	}	×
91
92	@Override
93	public boolean setTargetOffset(S state, PartPos center, Vec3i offset) {
94	IAspectWrite activeAspect = state.getActiveAspect();	×
95	if(activeAspect != null) {	×
96	activeAspect.onDeactivate(this, getTarget(center, state), state);	×
97	}
98	boolean ret = super.setTargetOffset(state, center, offset);	×
99	if(activeAspect != null) {	×
100	activeAspect.onActivate(this, getTarget(center, state), state);	×
101	}
102	return ret;	×
103	}
104
105	@Override
106	public void addDrops(PartTarget target, S state, List<ItemStack> itemStacks, boolean dropMainElement, boolean saveState) {
107	for(int i = 0; i < state.getInventory().getContainerSize(); i++) {	×
108	ItemStack itemStack = state.getInventory().getItem(i);	×
109	if(!itemStack.isEmpty()) {	×
110	itemStacks.add(itemStack);	×
111	}
112	}
113	state.getInventory().clearContent();	×
114	state.triggerAspectInfoUpdate((P) this, target, null, false);	×
115	super.addDrops(target, state, itemStacks, dropMainElement, saveState);	×
116	}	×
117
118	@Override
119	public void beforeNetworkKill(INetwork network, IPartNetwork partNetwork, PartTarget target, S state) {
120	super.beforeNetworkKill(network, partNetwork, target, state);	×
121	state.triggerAspectInfoUpdate((P) this, target, null, true);	×
122	}	×
123
124	@Override
125	public void afterNetworkAlive(INetwork network, IPartNetwork partNetwork, PartTarget target, S state) {
126	super.afterNetworkAlive(network, partNetwork, target, state);	×
127	updateActivation(target, state, null, true);	×
128	}	×
129
130	@Override
131	public List<IAspectWrite<?, ?>> getWriteAspects() {
132	if (aspectsWrite == null) {	×
133	aspectsWrite = Aspects.REGISTRY.getWriteAspects(this);	×
134	}
135	return aspectsWrite;	×
136	}
137
138	@Override
139	public boolean hasActiveVariable(IPartNetwork network, PartTarget target, S partState) {
140	return partState.hasVariable();	×
141	}
142
143	@Override
144	public <V extends IValue> IVariable<V> getActiveVariable(INetwork network, IPartNetwork partNetwork, PartTarget target, S partState) {
145	return partState.getVariable(network, partNetwork, ValueDeseralizationContext.of(target.getCenter().getPos().getLevel(true)));	×
146	}
147
148	@Override
149	public IAspectWrite getActiveAspect(PartTarget target, S partState) {
150	return partState.getActiveAspect();	×
151	}
152
153	@Override
154	public void updateActivation(PartTarget target, S partState, @Nullable Player player, boolean isNetworkInitializing) {
155	// Check inside the inventory for a variable item and determine everything with that.
156	int activeIndex = -1;	×
157	for(int i = 0 ; i < partState.getInventory().getContainerSize(); i++) {	×
158	if(!partState.getInventory().getItem(i).isEmpty()) {	×
159	activeIndex = i;	×
160	break;	×
161	}
162	}
163	IAspectWrite aspect = activeIndex == -1 ? null : getWriteAspects().get(activeIndex);	×
164	partState.triggerAspectInfoUpdate((P) this, target, aspect, isNetworkInitializing);	×
165
166	INetwork network = NetworkHelpers.getNetwork(target.getCenter()).orElse(null);	×
167	if (network != null && aspect != null) {	×
168	IPartNetwork partNetwork = NetworkHelpers.getPartNetwork(network).orElse(null);	×
169	if (partNetwork != null) {	×
170	NeoForge.EVENT_BUS.post(new PartWriterAspectEvent<>(network, partNetwork, target, (P) this,	×
171	partState, player, aspect, partState.getInventory().getItem(activeIndex)));	×
172	}
173	}
174	if (network != null && !isNetworkInitializing) {	×
175	network.getEventBus().post(new VariableContentsUpdatedEvent(network));	×
176	}
177	}	×
178
179	protected void onVariableContentsUpdated(IPartNetwork network, PartTarget target, S state) {
180	state.onVariableContentsUpdated((P) this, target);	×
181	}	×
182
183	protected IgnoredBlockStatus.Status getStatus(IPartStateWriter state) {
184	IgnoredBlockStatus.Status status = IgnoredBlockStatus.Status.INACTIVE;	×
185	if (state != null && !state.getInventory().isEmpty()) {	×
186	if (state.hasVariable() && state.isEnabled()) {	×
187	status = IgnoredBlockStatus.Status.ACTIVE;	×
188	} else {
189	status = IgnoredBlockStatus.Status.ERROR;	×
190	}
191	}
192	return status;	×
193	}
194
195	@Override
196	public BlockState getBlockState(IPartContainer partContainer,
197	Direction side) {
198	IgnoredBlockStatus.Status status = getStatus(partContainer != null	×
199	? (IPartStateWriter) partContainer.getPartState(side) : null);	×
200	return getBlock().defaultBlockState().setValue(IgnoredBlock.FACING, side)	×
201	.setValue(IgnoredBlockStatus.STATUS, status);	×
202	}
203
204	@Override
205	public void loadTooltip(S state, List<Component> lines) {
206	super.loadTooltip(state, lines);	×
207	IAspectWrite aspectWrite = state.getActiveAspect();	×
208	if (aspectWrite != null) {	×
209	if (state.hasVariable() && state.isEnabled()) {	×
210	lines.add(Component.translatable(	×
211	L10NValues.PART_TOOLTIP_WRITER_ACTIVEASPECT,
212	Component.translatable(aspectWrite.getTranslationKey()),	×
213	Component.translatable(aspectWrite.getValueType().getTranslationKey())	×
214	.withStyle(aspectWrite.getValueType().getDisplayColorFormat())));	×
215	} else {
216	lines.add(Component.translatable(L10NValues.PART_TOOLTIP_ERRORS)	×
217	.withStyle(ChatFormatting.RED));	×
218	for (Component error : state.getErrors(aspectWrite)) {	×
219	lines.add(error.copy().withStyle(ChatFormatting.RED));	×
220	}	×
221	}
222	} else {
223	lines.add(Component.translatable(L10NValues.PART_TOOLTIP_INACTIVE));	×
224	}
225	}	×
226
227	@Override
228	public Optional<MenuProvider> getContainerProvider(PartPos pos) {
229	return Optional.of(new MenuProvider() {	×
230	@Override
231	public Component getDisplayName() {
232	return Component.translatable(getTranslationKey());	×
233	}
234
235	@Nullable
236	@Override
237	public AbstractContainerMenu createMenu(int id, Inventory playerInventory, Player playerEntity) {
238	Triple<IPartContainer, PartTypeBase, PartTarget> data = PartHelpers.getContainerPartConstructionData(pos);	×
239	S partState = (S) data.getLeft().getPartState(data.getRight().getCenter().getSide());	×
240	return new ContainerPartWriter<>(id, playerInventory, partState.getInventory(),	×
241	data.getRight(), Optional.of(data.getLeft()), (PartTypeWriteBase) data.getMiddle());	×
242	}
243
244	@Override
245	public boolean shouldTriggerClientSideContainerClosingOnOpen() {
246	return false;	×
247	}
248	});
249	}
250
251	@Override
252	public void writeExtraGuiData(RegistryFriendlyByteBuf packetBuffer, PartPos pos, ServerPlayer player) {
253	// Write inventory size
254	packetBuffer.writeInt(getWriteAspects().size());	×
255	// Write part position
256	PacketCodecs.write(packetBuffer, pos);	×
257
258	super.writeExtraGuiData(packetBuffer, pos, player);	×
259	}	×
260
261	@Override
262	public boolean shouldTriggerBlockRenderUpdate(@Nullable S oldPartState, @Nullable S newPartState) {
263	return super.shouldTriggerBlockRenderUpdate(oldPartState, newPartState)	×
264	\|\| getStatus(oldPartState) != getStatus(newPartState);	×
265	}
266
267	}

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