13739195914

Committed 08 Mar 2025 03:58PM UTC coverage: 39.059% (+0.06%) from 39.002%

Build # 13739195914

Build Type

push

github

Committed by

rubensworks

Commit Message

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

Run Details

1966 of 8373 branches covered (23.48%)

Branch coverage included in aggregate %.

10307 of 23049 relevant lines covered (44.72%)

2.1 hits per line

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

0.0

/src/main/java/org/cyclops/integrateddynamics/part/aspect/write/AspectWriteBase.java

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

import net.minecraft.network.chat.Component;
import net.minecraft.resources.ResourceLocation;
import net.neoforged.api.distmarker.Dist;
import net.neoforged.api.distmarker.OnlyIn;
import org.cyclops.cyclopscore.helper.IModHelpers;
import org.cyclops.cyclopscore.init.ModBaseNeoForge;
import org.cyclops.integrateddynamics.api.evaluate.EvaluationException;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValue;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValueType;
import org.cyclops.integrateddynamics.api.evaluate.variable.IVariable;
import org.cyclops.integrateddynamics.api.network.INetwork;
import org.cyclops.integrateddynamics.api.network.IPartNetwork;
import org.cyclops.integrateddynamics.api.part.IPartState;
import org.cyclops.integrateddynamics.api.part.IPartType;
import org.cyclops.integrateddynamics.api.part.PartTarget;
import org.cyclops.integrateddynamics.api.part.aspect.IAspectWrite;
import org.cyclops.integrateddynamics.api.part.aspect.property.IAspectProperties;
import org.cyclops.integrateddynamics.api.part.write.IPartStateWriter;
import org.cyclops.integrateddynamics.api.part.write.IPartTypeWriter;
import org.cyclops.integrateddynamics.core.evaluate.variable.ValueHelpers;
import org.cyclops.integrateddynamics.core.helper.L10NValues;
import org.cyclops.integrateddynamics.part.aspect.AspectBase;
import org.cyclops.integrateddynamics.part.aspect.Aspects;

/**
 * Base class for write aspects.
 * @author rubensworks
 */
public abstract class AspectWriteBase<V extends IValue, T extends IValueType<V>> extends AspectBase<V, T>
        implements IAspectWrite<V, T> {

    protected final String unlocalizedTypeSuffix;

    public AspectWriteBase(ModBaseNeoForge mod, String unlocalizedTypeSuffix, IAspectProperties defaultProperties) {
        super(mod, defaultProperties);
        if(unlocalizedTypeSuffix == null) {
            unlocalizedTypeSuffix = "";
        }
        this.unlocalizedTypeSuffix = unlocalizedTypeSuffix;
        if(IModHelpers.get().getMinecraftHelpers().isClientSide()) {
            registerModelResourceLocation();
        }
    }

    @SuppressWarnings("unchecked")
    @Override
    public <P extends IPartType<P, S>, S extends IPartState<P>> void update(INetwork network, IPartNetwork partNetwork, P partType, PartTarget target, S state) {
        IPartTypeWriter partTypeWriter = (IPartTypeWriter) partType;
        IPartStateWriter writerState = (IPartStateWriter) state;
        IVariable variable = partTypeWriter.getActiveVariable(network, partNetwork, target, writerState);
        if(variable != null && writerState.getErrors(this).isEmpty()) {
            if (ValueHelpers.correspondsTo(variable, getValueType())) {
                if(writerState.isDeactivated() || writerState.checkAndResetFirstTick()) {
                    onActivate(partTypeWriter, target, writerState);
                }
                try {
                    write(partTypeWriter, target, writerState, variable);
                } catch (EvaluationException e) {
                    writerState.addError(this, e.getErrorMessage());
                    writerState.setDeactivated(true);
                    e.addResolutionListeners(() -> writerState.onVariableContentsUpdated(partTypeWriter, target));
                }
            } else {
                // This will only occur in cases where the variable is of any type, and the value type is more precise.
                // In all other cases, type checking will already have happen using the variable facades.
                try {
                    writerState.addError(this, Component.translatable(L10NValues.ASPECT_ERROR_INVALIDTYPE,
                        Component.translatable(getValueType().getTranslationKey()),
                        Component.translatable(variable.getValue().getType().getTranslationKey())));
                } catch (EvaluationException e) {
                    // Fallback to a less precise form of error reporting
                    writerState.addError(this, Component.translatable(L10NValues.ASPECT_ERROR_INVALIDTYPE,
                            Component.translatable(getValueType().getTranslationKey()),
                            Component.translatable(variable.getType().getTranslationKey())));
                }
                writerState.setDeactivated(true);
            }
        } else if(!writerState.isDeactivated()) {
            onDeactivate(partTypeWriter, target, writerState);
        }
    }

    @Override
    public <P extends IPartTypeWriter<P, S>, S extends IPartStateWriter<P>> void onActivate(P partType, PartTarget target, S state) {
        state.setDeactivated(false);
    }

    @Override
    public <P extends IPartTypeWriter<P, S>, S extends IPartStateWriter<P>> void onDeactivate(P partType, PartTarget target, S state) {
        state.setDeactivated(true);
    }

    @Override
    public <P extends IPartType<P, S>, S extends IPartState<P>> void setProperties(P partType, PartTarget target, S state, IAspectProperties properties) {
        onDeactivate((IPartTypeWriter) partType, target, (IPartStateWriter) state);
        super.setProperties(partType, target, state, properties);
        onActivate((IPartTypeWriter) partType, target, (IPartStateWriter) state);
    }

    protected String getUnlocalizedType() {
        return "write" + unlocalizedTypeSuffix;
    }

    @OnlyIn(Dist.CLIENT)
    protected void registerModelResourceLocation() {
        Aspects.REGISTRY.registerAspectModel(this,
                ResourceLocation.parse(getModId() + ":aspect/" + getUnlocalizedType().replaceAll("\\.", "/")));
    }

}

1	package org.cyclops.integrateddynamics.part.aspect.write;
2
3	import net.minecraft.network.chat.Component;
4	import net.minecraft.resources.ResourceLocation;
5	import net.neoforged.api.distmarker.Dist;
6	import net.neoforged.api.distmarker.OnlyIn;
7	import org.cyclops.cyclopscore.helper.IModHelpers;
8	import org.cyclops.cyclopscore.init.ModBaseNeoForge;
9	import org.cyclops.integrateddynamics.api.evaluate.EvaluationException;
10	import org.cyclops.integrateddynamics.api.evaluate.variable.IValue;
11	import org.cyclops.integrateddynamics.api.evaluate.variable.IValueType;
12	import org.cyclops.integrateddynamics.api.evaluate.variable.IVariable;
13	import org.cyclops.integrateddynamics.api.network.INetwork;
14	import org.cyclops.integrateddynamics.api.network.IPartNetwork;
15	import org.cyclops.integrateddynamics.api.part.IPartState;
16	import org.cyclops.integrateddynamics.api.part.IPartType;
17	import org.cyclops.integrateddynamics.api.part.PartTarget;
18	import org.cyclops.integrateddynamics.api.part.aspect.IAspectWrite;
19	import org.cyclops.integrateddynamics.api.part.aspect.property.IAspectProperties;
20	import org.cyclops.integrateddynamics.api.part.write.IPartStateWriter;
21	import org.cyclops.integrateddynamics.api.part.write.IPartTypeWriter;
22	import org.cyclops.integrateddynamics.core.evaluate.variable.ValueHelpers;
23	import org.cyclops.integrateddynamics.core.helper.L10NValues;
24	import org.cyclops.integrateddynamics.part.aspect.AspectBase;
25	import org.cyclops.integrateddynamics.part.aspect.Aspects;
26
27	/**
28	* Base class for write aspects.
29	* @author rubensworks
30	*/
31	public abstract class AspectWriteBase<V extends IValue, T extends IValueType<V>> extends AspectBase<V, T>
32	implements IAspectWrite<V, T> {
33
34	protected final String unlocalizedTypeSuffix;
35
36	public AspectWriteBase(ModBaseNeoForge mod, String unlocalizedTypeSuffix, IAspectProperties defaultProperties) {
37	super(mod, defaultProperties);	×
38	if(unlocalizedTypeSuffix == null) {	×
39	unlocalizedTypeSuffix = "";	×
40	}
41	this.unlocalizedTypeSuffix = unlocalizedTypeSuffix;	×
42	if(IModHelpers.get().getMinecraftHelpers().isClientSide()) {	×
43	registerModelResourceLocation();	×
44	}
45	}	×
46
47	@SuppressWarnings("unchecked")
48	@Override
49	public <P extends IPartType<P, S>, S extends IPartState<P>> void update(INetwork network, IPartNetwork partNetwork, P partType, PartTarget target, S state) {
50	IPartTypeWriter partTypeWriter = (IPartTypeWriter) partType;	×
51	IPartStateWriter writerState = (IPartStateWriter) state;	×
52	IVariable variable = partTypeWriter.getActiveVariable(network, partNetwork, target, writerState);	×
53	if(variable != null && writerState.getErrors(this).isEmpty()) {	×
54	if (ValueHelpers.correspondsTo(variable, getValueType())) {	×
55	if(writerState.isDeactivated() \|\| writerState.checkAndResetFirstTick()) {	×
56	onActivate(partTypeWriter, target, writerState);	×
57	}
58	try {
59	write(partTypeWriter, target, writerState, variable);	×
60	} catch (EvaluationException e) {	×
61	writerState.addError(this, e.getErrorMessage());	×
62	writerState.setDeactivated(true);	×
63	e.addResolutionListeners(() -> writerState.onVariableContentsUpdated(partTypeWriter, target));	×
64	}	×
65	} else {
66	// This will only occur in cases where the variable is of any type, and the value type is more precise.
67	// In all other cases, type checking will already have happen using the variable facades.
68	try {
69	writerState.addError(this, Component.translatable(L10NValues.ASPECT_ERROR_INVALIDTYPE,	×
70	Component.translatable(getValueType().getTranslationKey()),	×
71	Component.translatable(variable.getValue().getType().getTranslationKey())));	×
72	} catch (EvaluationException e) {	×
73	// Fallback to a less precise form of error reporting
74	writerState.addError(this, Component.translatable(L10NValues.ASPECT_ERROR_INVALIDTYPE,	×
75	Component.translatable(getValueType().getTranslationKey()),	×
76	Component.translatable(variable.getType().getTranslationKey())));	×
77	}	×
78	writerState.setDeactivated(true);	×
79	}
80	} else if(!writerState.isDeactivated()) {	×
81	onDeactivate(partTypeWriter, target, writerState);	×
82	}
83	}	×
84
85	@Override
86	public <P extends IPartTypeWriter<P, S>, S extends IPartStateWriter<P>> void onActivate(P partType, PartTarget target, S state) {
87	state.setDeactivated(false);	×
88	}	×
89
90	@Override
91	public <P extends IPartTypeWriter<P, S>, S extends IPartStateWriter<P>> void onDeactivate(P partType, PartTarget target, S state) {
92	state.setDeactivated(true);	×
93	}	×
94
95	@Override
96	public <P extends IPartType<P, S>, S extends IPartState<P>> void setProperties(P partType, PartTarget target, S state, IAspectProperties properties) {
97	onDeactivate((IPartTypeWriter) partType, target, (IPartStateWriter) state);	×
98	super.setProperties(partType, target, state, properties);	×
99	onActivate((IPartTypeWriter) partType, target, (IPartStateWriter) state);	×
100	}	×
101
102	protected String getUnlocalizedType() {
103	return "write" + unlocalizedTypeSuffix;	×
104	}
105
106	@OnlyIn(Dist.CLIENT)
107	protected void registerModelResourceLocation() {
108	Aspects.REGISTRY.registerAspectModel(this,	×
109	ResourceLocation.parse(getModId() + ":aspect/" + getUnlocalizedType().replaceAll("\\.", "/")));	×
110	}	×
111
112	}

CyclopsMC / IntegratedDynamics / 13739195914

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