22182377337

Committed 19 Feb 2026 12:46PM UTC coverage: 44.49% (-1.7%) from 46.183%

Build # 22182377337

Build Type

push

github

Committed by

rubensworks

Commit Message

Fix performance workflow failing

Run Details

2663 of 8850 branches covered (30.09%)

Branch coverage included in aggregate %.

12028 of 24171 relevant lines covered (49.76%)

2.36 hits per line

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

67.38

/src/main/java/org/cyclops/integrateddynamics/api/part/PartTypeAdapter.java

package org.cyclops.integrateddynamics.api.part;

import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.core.NonNullList;
import net.minecraft.core.Vec3i;
import net.minecraft.nbt.CompoundTag;
import net.minecraft.network.chat.Component;
import net.minecraft.util.RandomSource;
import net.minecraft.world.InteractionHand;
import net.minecraft.world.InteractionResult;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.level.BlockGetter;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.phys.BlockHitResult;
import org.cyclops.integrateddynamics.RegistryEntries;
import org.cyclops.integrateddynamics.api.evaluate.variable.ValueDeseralizationContext;
import org.cyclops.integrateddynamics.GeneralConfig;
import org.cyclops.integrateddynamics.api.network.INetwork;
import org.cyclops.integrateddynamics.api.network.IPartNetwork;
import org.cyclops.integrateddynamics.api.network.IPartNetworkElement;
import org.cyclops.integrateddynamics.api.network.event.INetworkEvent;

import javax.annotation.Nullable;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * Default implementation of {@link IPartType}.
 * @author rubensworks
 */
public abstract class PartTypeAdapter<P extends IPartType<P, S>, S extends IPartState<P>> implements IPartType<P, S> {

    private String translationKey = null;

    @Override
    public final String getTranslationKey() {
        return translationKey != null ? translationKey : (translationKey = createTranslationKey());
    }

    protected abstract String createTranslationKey();

    @Override
    public boolean isSolid(S state) {
        return false;
    }

    @Override
    public void toNBT(ValueDeseralizationContext valueDeseralizationContext, CompoundTag tag, S partState) {
        partState.writeToNBT(valueDeseralizationContext, tag);
    }

    @Override
    public S fromNBT(ValueDeseralizationContext valueDeseralizationContext, CompoundTag tag) {
        S partState = constructDefaultState();
        partState.readFromNBT(valueDeseralizationContext, tag);
        partState.gatherCapabilities((P) this);
        return partState;
    }

    @Override
    public void setUpdateInterval(S state, int updateInterval) {
        state.setUpdateInterval(updateInterval);
    }

    @Override
    public int getUpdateInterval(S state) {
        return Math.max(getMinimumUpdateInterval(state), state.getUpdateInterval());
    }

    @Override
    public int getMinimumUpdateInterval(S state) {
        return Math.max(GeneralConfig.partsMinimumUpdateInterval, GeneralConfig.partMinimumUpdateIntervalsMap.getOrDefault(this, 1));
    }

    @Override
    public void setPriorityAndChannel(INetwork network, IPartNetwork partNetwork, PartTarget target, S state, int priority, int channel) {
        //noinspection deprecation
        state.setPriority(priority);
        state.setChannel(channel);
    }

    @Override
    public int getPriority(S state) {
        return state.getPriority();
    }

    @Override
    public int getChannel(S state) {
        return state.getChannel();
    }

    @Override
    public Vec3i getTargetOffset(S state) {
        return state.getTargetOffset();
    }

    @Override
    public boolean setTargetOffset(S state, PartPos center, Vec3i offset) {
        int max = state.getMaxOffset();
        if (offset.getX() >= -max && offset.getY() >= -max && offset.getZ() >= -max
                && offset.getX() <= max && offset.getY() <= max && offset.getZ() <= max) {
            state.setTargetOffset(offset);
            return true;
        }
        return false;
    }

    @Override
    public void setTargetSideOverride(S state, @Nullable Direction side) {
        state.setTargetSideOverride(side);
    }

    @Nullable
    @Override
    public Direction getTargetSideOverride(S state) {
        return state.getTargetSideOverride();
    }

    @Override
    public PartTarget getTarget(PartPos pos, S state) {
        PartTarget target = PartTarget.fromCenter(pos);
        Direction sideOverride = getTargetSideOverride(state);
        if (sideOverride != null) {
            target = target.forTargetSide(sideOverride);
        }
        Vec3i offset = getTargetOffset(state);
        if (offset.compareTo(Vec3i.ZERO) != 0) {
            target = target.forOffset(offset);
        }
        return target;
    }

    protected boolean hasOffsetVariables(S state) {
        NonNullList<ItemStack> inventory = state.getInventoryNamed("offsetVariablesInventory");
        return inventory != null && inventory.stream().anyMatch(item -> !item.isEmpty());
    }

    @Override
    public void onOffsetVariablesChanged(PartTarget target, S state) {
        state.markOffsetVariablesChanged();
    }

    @Override
    public boolean isUpdate(S state) {
        return hasOffsetVariables(state);
    }

    @Override
    public void update(INetwork network, IPartNetwork partNetwork, PartTarget target, S state) {
        state.updateOffsetVariables((P) this, network, partNetwork, target);
    }

    @Override
    public void beforeNetworkKill(INetwork network, IPartNetwork partNetwork, PartTarget target, S state) {

    }

    @Override
    public void afterNetworkAlive(INetwork network, IPartNetwork partNetwork, PartTarget target, S state) {

    }

    @Override
    public void afterNetworkReAlive(INetwork network, IPartNetwork partNetwork, PartTarget target, S state) {
        // This resets any errored offset variables and forces them to reload.
        state.markOffsetVariablesChanged();
    }

    @Override
    public ItemStack getItemStack(ValueDeseralizationContext valueDeseralizationContext, S state, boolean saveState) {
        ItemStack itemStack = new ItemStack(getItem());
        if (saveState) {
            CompoundTag tag = new CompoundTag();
            toNBT(valueDeseralizationContext, tag, state);
            itemStack.set(RegistryEntries.DATACOMPONENT_PART_STATE, tag);
        }
        return itemStack;
    }

    @Override
    public ItemStack getCloneItemStack(Level world, BlockPos pos, S state) {
        return getItemStack(ValueDeseralizationContext.of(world), state, false);
    }

    @Override
    public S getState(ValueDeseralizationContext valueDeseralizationContext, ItemStack itemStack) {
        S partState = null;
        if(!itemStack.isEmpty() && itemStack.has(RegistryEntries.DATACOMPONENT_PART_STATE)) {
            partState = fromNBT(valueDeseralizationContext, itemStack.get(RegistryEntries.DATACOMPONENT_PART_STATE));
        }
        if(partState == null) {
            partState = defaultBlockState();
        }
        return partState;
    }

    /**
     * @return Constructor call for a new default state for this part type.
     */
    protected abstract S constructDefaultState();

    @Override
    public S defaultBlockState() {
        S defaultState = constructDefaultState();
        defaultState.generateId();
        defaultState.gatherCapabilities((P) this);
        return defaultState;
    }

    @Override
    public void addDrops(PartTarget target, S state, List<ItemStack> itemStacks, boolean dropMainElement, boolean saveState) {
        if(dropMainElement) {
            itemStacks.add(getItemStack(ValueDeseralizationContext.of(target.getCenter().getPos().getLevel(true)), state, saveState));
        }

        // Drop contents of named inventories
        for (Map.Entry<String, NonNullList<ItemStack>> entry : state.getInventoriesNamed().entrySet()) {
            for (ItemStack itemStack : entry.getValue()) {
                if (!itemStack.isEmpty()) {
                    itemStacks.add(itemStack);
                }
            }
        }
        state.clearInventoriesNamed();
    }

    @Override
    public void onNetworkAddition(INetwork network, IPartNetwork partNetwork, PartTarget target, S state) {
        state.initializeOffsets(target);
    }

    @Override
    public void onNetworkRemoval(INetwork network, IPartNetwork partNetwork, PartTarget target, S state) {

    }

    @Override
    public InteractionResult onPartActivated(S partState, BlockPos pos, Level world, Player player, InteractionHand hand, ItemStack heldItem, BlockHitResult hit) {
        return InteractionResult.PASS;
    }

    @Override
    public void updateTick(Level world, BlockPos pos, S partState, RandomSource random) {

    }

    @Override
    public void onPreRemoved(INetwork network, IPartNetwork partNetwork, PartTarget target, S state) {

    }

    @Override
    public void onPostRemoved(INetwork network, IPartNetwork partNetwork, PartTarget target, S state) {

    }

    @Override
    public void onBlockNeighborChange(INetwork network, IPartNetwork partNetwork, PartTarget target, S state,
                                      BlockGetter world, Block neighbourBlock, BlockPos neighbourBlockPos) {

    }

    @Override
    public int getConsumptionRate(S state) {
        return 0;
    }

    @Override
    public void postUpdate(INetwork network, IPartNetwork partNetwork, PartTarget target, S state, boolean updated) {
        setEnabled(state, updated);
    }

    @Override
    public boolean isEnabled(S state) {
        return state.isEnabled();
    }

    @Override
    public void setEnabled(S state, boolean enabled) {
        state.setEnabled(enabled);
    }

    @Override
    public void loadTooltip(S state, List<Component> lines) {

    }

    @Override
    public void loadTooltip(ItemStack itemStack, List<Component> lines) {

    }

    @Override
    public boolean shouldTriggerBlockRenderUpdate(@Nullable S oldPartState, @Nullable S newPartState) {
        return oldPartState == null || newPartState == null || oldPartState.isForceBlockRenderUpdateAndReset();
    }

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

    @Override
    public Set<Class<? extends INetworkEvent>> getSubscribedEvents() {
        return Collections.emptySet();
    }

    @Override
    public void onEvent(INetworkEvent event, IPartNetworkElement<P, S> networkElement) {

    }
}

1	package org.cyclops.integrateddynamics.api.part;
2
3	import net.minecraft.core.BlockPos;
4	import net.minecraft.core.Direction;
5	import net.minecraft.core.NonNullList;
6	import net.minecraft.core.Vec3i;
7	import net.minecraft.nbt.CompoundTag;
8	import net.minecraft.network.chat.Component;
9	import net.minecraft.util.RandomSource;
10	import net.minecraft.world.InteractionHand;
11	import net.minecraft.world.InteractionResult;
12	import net.minecraft.world.entity.player.Player;
13	import net.minecraft.world.item.ItemStack;
14	import net.minecraft.world.level.BlockGetter;
15	import net.minecraft.world.level.Level;
16	import net.minecraft.world.level.block.Block;
17	import net.minecraft.world.phys.BlockHitResult;
18	import org.cyclops.integrateddynamics.RegistryEntries;
19	import org.cyclops.integrateddynamics.api.evaluate.variable.ValueDeseralizationContext;
20	import org.cyclops.integrateddynamics.GeneralConfig;
21	import org.cyclops.integrateddynamics.api.network.INetwork;
22	import org.cyclops.integrateddynamics.api.network.IPartNetwork;
23	import org.cyclops.integrateddynamics.api.network.IPartNetworkElement;
24	import org.cyclops.integrateddynamics.api.network.event.INetworkEvent;
25
26	import javax.annotation.Nullable;
27	import java.util.Collections;
28	import java.util.List;
29	import java.util.Map;
30	import java.util.Set;
31
32	/**
33	* Default implementation of {@link IPartType}.
34	* @author rubensworks
35	*/
36	public abstract class PartTypeAdapter<P extends IPartType<P, S>, S extends IPartState<P>> implements IPartType<P, S> {	2✔
37
38	private String translationKey = null;	4✔
39
40	@Override
41	public final String getTranslationKey() {
42	return translationKey != null ? translationKey : (translationKey = createTranslationKey());	12✔
43	}
44
45	protected abstract String createTranslationKey();
46
47	@Override
48	public boolean isSolid(S state) {
49	return false;	×
50	}
51
52	@Override
53	public void toNBT(ValueDeseralizationContext valueDeseralizationContext, CompoundTag tag, S partState) {
54	partState.writeToNBT(valueDeseralizationContext, tag);	4✔
55	}	1✔
56
57	@Override
58	public S fromNBT(ValueDeseralizationContext valueDeseralizationContext, CompoundTag tag) {
59	S partState = constructDefaultState();	3✔
60	partState.readFromNBT(valueDeseralizationContext, tag);	4✔
61	partState.gatherCapabilities((P) this);	3✔
62	return partState;	2✔
63	}
64
65	@Override
66	public void setUpdateInterval(S state, int updateInterval) {
67	state.setUpdateInterval(updateInterval);	×
68	}	×
69
70	@Override
71	public int getUpdateInterval(S state) {
72	return Math.max(getMinimumUpdateInterval(state), state.getUpdateInterval());	7✔
73	}
74
75	@Override
76	public int getMinimumUpdateInterval(S state) {
77	return Math.max(GeneralConfig.partsMinimumUpdateInterval, GeneralConfig.partMinimumUpdateIntervalsMap.getOrDefault(this, 1));	10✔
78	}
79
80	@Override
81	public void setPriorityAndChannel(INetwork network, IPartNetwork partNetwork, PartTarget target, S state, int priority, int channel) {
82	//noinspection deprecation
83	state.setPriority(priority);	×
84	state.setChannel(channel);	×
85	}	×
86
87	@Override
88	public int getPriority(S state) {
89	return state.getPriority();	3✔
90	}
91
92	@Override
93	public int getChannel(S state) {
94	return state.getChannel();	×
95	}
96
97	@Override
98	public Vec3i getTargetOffset(S state) {
99	return state.getTargetOffset();	3✔
100	}
101
102	@Override
103	public boolean setTargetOffset(S state, PartPos center, Vec3i offset) {
104	int max = state.getMaxOffset();	3✔
105	if (offset.getX() >= -max && offset.getY() >= -max && offset.getZ() >= -max	16!
106	&& offset.getX() <= max && offset.getY() <= max && offset.getZ() <= max) {	11!
107	state.setTargetOffset(offset);	3✔
108	return true;	2✔
109	}
110	return false;	2✔
111	}
112
113	@Override
114	public void setTargetSideOverride(S state, @Nullable Direction side) {
115	state.setTargetSideOverride(side);	3✔
116	}	1✔
117
118	@Nullable
119	@Override
120	public Direction getTargetSideOverride(S state) {
121	return state.getTargetSideOverride();	3✔
122	}
123
124	@Override
125	public PartTarget getTarget(PartPos pos, S state) {
126	PartTarget target = PartTarget.fromCenter(pos);	3✔
127	Direction sideOverride = getTargetSideOverride(state);	4✔
128	if (sideOverride != null) {	2✔
129	target = target.forTargetSide(sideOverride);	4✔
130	}
131	Vec3i offset = getTargetOffset(state);	4✔
132	if (offset.compareTo(Vec3i.ZERO) != 0) {	4✔
133	target = target.forOffset(offset);	4✔
134	}
135	return target;	2✔
136	}
137
138	protected boolean hasOffsetVariables(S state) {
139	NonNullList<ItemStack> inventory = state.getInventoryNamed("offsetVariablesInventory");	4✔
140	return inventory != null && inventory.stream().anyMatch(item -> !item.isEmpty());	4!
141	}
142
143	@Override
144	public void onOffsetVariablesChanged(PartTarget target, S state) {
145	state.markOffsetVariablesChanged();	×
146	}	×
147
148	@Override
149	public boolean isUpdate(S state) {
150	return hasOffsetVariables(state);	4✔
151	}
152
153	@Override
154	public void update(INetwork network, IPartNetwork partNetwork, PartTarget target, S state) {
155	state.updateOffsetVariables((P) this, network, partNetwork, target);	6✔
156	}	1✔
157
158	@Override
159	public void beforeNetworkKill(INetwork network, IPartNetwork partNetwork, PartTarget target, S state) {
160
161	}	1✔
162
163	@Override
164	public void afterNetworkAlive(INetwork network, IPartNetwork partNetwork, PartTarget target, S state) {
165
166	}	1✔
167
168	@Override
169	public void afterNetworkReAlive(INetwork network, IPartNetwork partNetwork, PartTarget target, S state) {
170	// This resets any errored offset variables and forces them to reload.
171	state.markOffsetVariablesChanged();	2✔
172	}	1✔
173
174	@Override
175	public ItemStack getItemStack(ValueDeseralizationContext valueDeseralizationContext, S state, boolean saveState) {
176	ItemStack itemStack = new ItemStack(getItem());	6✔
177	if (saveState) {	2✔
178	CompoundTag tag = new CompoundTag();	4✔
179	toNBT(valueDeseralizationContext, tag, state);	5✔
180	itemStack.set(RegistryEntries.DATACOMPONENT_PART_STATE, tag);	5✔
181	}
182	return itemStack;	2✔
183	}
184
185	@Override
186	public ItemStack getCloneItemStack(Level world, BlockPos pos, S state) {
187	return getItemStack(ValueDeseralizationContext.of(world), state, false);	×
188	}
189
190	@Override
191	public S getState(ValueDeseralizationContext valueDeseralizationContext, ItemStack itemStack) {
192	S partState = null;	2✔
193	if(!itemStack.isEmpty() && itemStack.has(RegistryEntries.DATACOMPONENT_PART_STATE)) {	7!
194	partState = fromNBT(valueDeseralizationContext, itemStack.get(RegistryEntries.DATACOMPONENT_PART_STATE));	8✔
195	}
196	if(partState == null) {	2✔
197	partState = defaultBlockState();	3✔
198	}
199	return partState;	2✔
200	}
201
202	/**
203	* @return Constructor call for a new default state for this part type.
204	*/
205	protected abstract S constructDefaultState();
206
207	@Override
208	public S defaultBlockState() {
209	S defaultState = constructDefaultState();	3✔
210	defaultState.generateId();	2✔
211	defaultState.gatherCapabilities((P) this);	3✔
212	return defaultState;	2✔
213	}
214
215	@Override
216	public void addDrops(PartTarget target, S state, List<ItemStack> itemStacks, boolean dropMainElement, boolean saveState) {
217	if(dropMainElement) {	2✔
218	itemStacks.add(getItemStack(ValueDeseralizationContext.of(target.getCenter().getPos().getLevel(true)), state, saveState));	13✔
219	}
220
221	// Drop contents of named inventories
222	for (Map.Entry<String, NonNullList<ItemStack>> entry : state.getInventoriesNamed().entrySet()) {	8!
223	for (ItemStack itemStack : entry.getValue()) {	×
224	if (!itemStack.isEmpty()) {	×
225	itemStacks.add(itemStack);	×
226	}
227	}	×
228	}	×
229	state.clearInventoriesNamed();	2✔
230	}	1✔
231
232	@Override
233	public void onNetworkAddition(INetwork network, IPartNetwork partNetwork, PartTarget target, S state) {
234	state.initializeOffsets(target);	3✔
235	}	1✔
236
237	@Override
238	public void onNetworkRemoval(INetwork network, IPartNetwork partNetwork, PartTarget target, S state) {
239
240	}	1✔
241
242	@Override
243	public InteractionResult onPartActivated(S partState, BlockPos pos, Level world, Player player, InteractionHand hand, ItemStack heldItem, BlockHitResult hit) {
244	return InteractionResult.PASS;	×
245	}
246
247	@Override
248	public void updateTick(Level world, BlockPos pos, S partState, RandomSource random) {
249
250	}	×
251
252	@Override
253	public void onPreRemoved(INetwork network, IPartNetwork partNetwork, PartTarget target, S state) {
254
255	}	1✔
256
257	@Override
258	public void onPostRemoved(INetwork network, IPartNetwork partNetwork, PartTarget target, S state) {
259
260	}	1✔
261
262	@Override
263	public void onBlockNeighborChange(INetwork network, IPartNetwork partNetwork, PartTarget target, S state,
264	BlockGetter world, Block neighbourBlock, BlockPos neighbourBlockPos) {
265
266	}	1✔
267
268	@Override
269	public int getConsumptionRate(S state) {
270	return 0;	×
271	}
272
273	@Override
274	public void postUpdate(INetwork network, IPartNetwork partNetwork, PartTarget target, S state, boolean updated) {
275	setEnabled(state, updated);	4✔
276	}	1✔
277
278	@Override
279	public boolean isEnabled(S state) {
280	return state.isEnabled();	×
281	}
282
283	@Override
284	public void setEnabled(S state, boolean enabled) {
285	state.setEnabled(enabled);	3✔
286	}	1✔
287
288	@Override
289	public void loadTooltip(S state, List<Component> lines) {
290
291	}	×
292
293	@Override
294	public void loadTooltip(ItemStack itemStack, List<Component> lines) {
295
296	}	×
297
298	@Override
299	public boolean shouldTriggerBlockRenderUpdate(@Nullable S oldPartState, @Nullable S newPartState) {
300	return oldPartState == null \|\| newPartState == null \|\| oldPartState.isForceBlockRenderUpdateAndReset();	×
301	}
302
303	@Override
304	public boolean hasEventSubscriptions() {
305	return false;	×
306	}
307
308	@Override
309	public Set<Class<? extends INetworkEvent>> getSubscribedEvents() {
310	return Collections.emptySet();	×
311	}
312
313	@Override
314	public void onEvent(INetworkEvent event, IPartNetworkElement<P, S> networkElement) {
315
316	}	×
317	}

CyclopsMC / IntegratedDynamics / 22182377337

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