23358440897

Committed 20 Mar 2026 07:05PM UTC coverage: 53.697% (-0.04%) from 53.738%

Build # 23358440897

Build Type

push

github

Committed by

rubensworks

Commit Message

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

Run Details

3054 of 8913 branches covered (34.26%)

Branch coverage included in aggregate %.

18675 of 31553 relevant lines covered (59.19%)

3.06 hits per line

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

65.99

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

package org.cyclops.integrateddynamics.api.part;

import com.mojang.logging.LogUtils;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.core.NonNullList;
import net.minecraft.core.Vec3i;
import net.minecraft.network.chat.Component;
import net.minecraft.util.ProblemReporter;
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.storage.TagValueInput;
import net.minecraft.world.level.storage.TagValueOutput;
import net.minecraft.world.level.storage.ValueInput;
import net.minecraft.world.level.storage.ValueOutput;
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 org.slf4j.Logger;

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

/**
 * 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 static final Logger LOGGER = LogUtils.getLogger();

    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 serializeState(ValueOutput valueOutput, S partState) {
        partState.serialize(valueOutput);
    }

    @Override
    public S deserializeState(ValueInput valueInput) {
        S partState = constructDefaultState();
        partState.deserialize(valueInput);
        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, ProblemReporter.PathElement problemPath, S state, boolean saveState) {
        ItemStack itemStack = new ItemStack(getItem());
        if (saveState) {
            try (ProblemReporter.ScopedCollector scopedCollector = new ProblemReporter.ScopedCollector(problemPath, LOGGER)) {
                TagValueOutput valueOutput = TagValueOutput.createWithContext(scopedCollector, valueDeseralizationContext.holderLookupProvider());
                serializeState(valueOutput, state);
                itemStack.set(RegistryEntries.DATACOMPONENT_PART_STATE, valueOutput.buildResult());
            }
        }
        return itemStack;
    }

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

    @Override
    public S getState(ValueDeseralizationContext valueDeseralizationContext, ProblemReporter.PathElement problemPath, ItemStack itemStack) {
        S partState = null;
        if(!itemStack.isEmpty() && itemStack.has(RegistryEntries.DATACOMPONENT_PART_STATE)) {
            try (ProblemReporter.ScopedCollector scopedCollector = new ProblemReporter.ScopedCollector(problemPath, LOGGER)) {
                ValueInput input = TagValueInput.create(
                        scopedCollector,
                        valueDeseralizationContext.holderLookupProvider(),
                        itemStack.get(RegistryEntries.DATACOMPONENT_PART_STATE)
                );
                partState = deserializeState(input);
            }
        }
        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)), new PartPathElement(target.getCenter().getPos().getBlockPos()), 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, @Nullable Direction side) {

    }

    @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, Consumer<Component> tooltipAdder) {

    }

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

CyclopsMC / IntegratedDynamics / 23358440897

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