20820179538

Committed 08 Jan 2026 02:27PM UTC coverage: 45.002% (-0.04%) from 45.046%

Build # 20820179538

Build Type

push

github

Committed by

rubensworks

Commit Message

Fix part states not being revalidated, Closes #1588

Run Details

2611 of 8588 branches covered (30.4%)

Branch coverage included in aggregate %.

11868 of 23586 relevant lines covered (50.32%)

2.39 hits per line

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

70.14

/src/main/java/org/cyclops/integrateddynamics/core/network/PartNetworkElement.java

package org.cyclops.integrateddynamics.core.network;

import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.level.BlockGetter;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.state.BlockState;
import org.cyclops.cyclopscore.datastructure.DimPos;
import org.cyclops.integrateddynamics.api.PartStateException;
import org.cyclops.integrateddynamics.api.network.*;
import org.cyclops.integrateddynamics.api.part.*;
import org.cyclops.integrateddynamics.core.helper.NetworkHelpers;
import org.cyclops.integrateddynamics.core.helper.PartHelpers;

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

/**
 * A network element for parts.
 * @author rubensworks
 */
public class PartNetworkElement<P extends IPartType<P, S>, S extends IPartState<P>> extends NetworkElementBase
        implements IPartNetworkElement<P, S>, IEnergyConsumingNetworkElement {

    private final P part;
    private final PartPos center;

    private S tempState = null;

    public PartNetworkElement(P part, PartPos center) {
        this.part = part;
        this.center = center;
    }

    protected static DimPos getCenterPos(PartTarget target) {
        return target.getCenter().getPos();
    }

    protected static Direction getCenterSide(PartTarget target) {
        return target.getCenter().getSide();
    }

    protected static DimPos getTargetPos(PartTarget target) {
        return target.getTarget().getPos();
    }

    protected static Direction getTargetSide(PartTarget target) {
        return target.getTarget().getSide();
    }

    @Override
    public P getPart() {
        return part;
    }

    @Override
    public PartTarget getTarget() {
        return getPart().getTarget(this.center, getPartState());
    }

    public PartTarget getTarget(S partState) {
        return getPart().getTarget(this.center, partState);
    }

    public S getTempState() {
        return tempState;
    }

    public void setTempState(S tempState) {
        this.tempState = tempState;
    }

    @Override
    public IPartContainer getPartContainer() {
        return PartHelpers.getPartContainerChecked(this.center.getPos(), this.center.getSide());
    }

    public IPartContainer getPartContainer(BlockState blockState) {
        return PartHelpers.getPartContainerChecked(this.center.getPos(), this.center.getSide(), blockState);
    }

    public Optional<IPartContainer> getPartContainerOptional() {
        return PartHelpers.getPartContainer(this.center.getPos(), this.center.getSide());
    }

    @Override
    public void setPriorityAndChannel(INetwork network, int priority, int channel) {
        //noinspection deprecation
        part.setPriorityAndChannel(network, NetworkHelpers.getPartNetworkChecked(network), getTarget(), getPartState(), priority, channel);
    }

    @Override
    public int getPriority() {
        return hasPartState() ? part.getPriority(getPartState()) : 0;
    }

    @Override
    public int getChannel() {
        return hasPartState() ? part.getChannel(getPartState()) : IPositionedAddonsNetwork.DEFAULT_CHANNEL;
    }

    @Override
    public boolean canRevalidate(INetwork network) {
        return canRevalidatePositioned(network, this.center.getPos());
    }

    @Override
    public void revalidate(INetwork network) {
        super.revalidate(network);
        if (revalidatePositioned(network, this.center.getPos())) {
            part.afterNetworkReAlive(network, NetworkHelpers.getPartNetworkChecked(network), PartTarget.fromCenter(this.center), getPartState());
        }
    }

    @Override
    public boolean isLoaded() {
        return INetworkElement.shouldTick(this.center.getPos());
    }

    public boolean hasPartState() {
        if (isLoaded()) {
            return getPartContainerOptional()
                    .map(partContainer -> partContainer.hasPart(this.center.getSide()))
                    .orElse(false);
        }
        return false;
    }

    @Override
    public S getPartState() throws PartStateException {
        IPartContainer partContainer = getPartContainer();
        if(partContainer != null) {
            return (S) partContainer.getPartState(this.center.getSide());
        } else {
            throw new PartStateException(this.center.getPos(), this.center.getSide());
        }
    }

    public S getPartState(BlockState blockState) throws PartStateException {
        IPartContainer partContainer = getPartContainer(blockState);
        if(partContainer != null) {
            return (S) partContainer.getPartState(this.center.getSide());
        } else {
            throw new PartStateException(this.center.getPos(), this.center.getSide());
        }
    }

    @Override
    public int getConsumptionRate() {
        return getPart().getConsumptionRate(getPartState());
    }

    @Override
    public void postUpdate(INetwork network, boolean updated) {
        part.postUpdate(network, NetworkHelpers.getPartNetworkChecked(network), getTarget(), getPartState(), updated);
    }

    @Override
    public int getUpdateInterval() {
        return part.getUpdateInterval(getPartState());
    }

    @Override
    public boolean isUpdate() {
        return part.isUpdate(getPartState());
    }

    @Override
    public void update(INetwork network) {
        part.update(network, NetworkHelpers.getPartNetworkChecked(network), getTarget(), getPartState());
    }

    @Override
    public void beforeNetworkKill(INetwork network) {
        part.beforeNetworkKill(network, NetworkHelpers.getPartNetworkChecked(network), getTarget(), getPartState());
    }

    @Override
    public void beforeNetworkKill(INetwork network, BlockState blockState) {
        S partState = getPartState(blockState);
        part.beforeNetworkKill(network, NetworkHelpers.getPartNetworkChecked(network), getTarget(partState), partState);
    }

    @Override
    public void afterNetworkAlive(INetwork network) {
        part.afterNetworkAlive(network, NetworkHelpers.getPartNetworkChecked(network), getTarget(), getPartState());
    }

    @Override
    public void afterNetworkReAlive(INetwork network) {
        part.afterNetworkReAlive(network, NetworkHelpers.getPartNetworkChecked(network), getTarget(), getPartState());
    }

    @Override
    public void addDrops(List<ItemStack> itemStacks, boolean dropMainElement, boolean saveState) {
        part.addDrops(getTarget(), getPartState(), itemStacks, dropMainElement, saveState);
    }

    @Override
    public void addDrops(BlockState blockState, List<ItemStack> itemStacks, boolean dropMainElement, boolean saveState) {
        S partState = getPartState(blockState);
        part.addDrops(getTarget(partState), partState, itemStacks, dropMainElement, saveState);
    }

    @Override
    public boolean onNetworkAddition(INetwork network) {
        IPartNetwork partNetwork = NetworkHelpers.getPartNetworkChecked(network);
        boolean res = partNetwork.addPart(getPartState().getId(), this.center);
        if(res) {
            part.onNetworkAddition(network, partNetwork, getTarget(), getPartState());
        }
        return res;
    }

    @Override
    public void onNetworkRemoval(INetwork network) {
        IPartNetwork partNetwork = NetworkHelpers.getPartNetworkChecked(network);
        partNetwork.removePart(getPartState().getId());
        part.onNetworkRemoval(network, partNetwork, getTarget(), getPartState());
    }

    @Override
    public void onNetworkRemoval(INetwork network, BlockState blockState) {
        IPartNetwork partNetwork = NetworkHelpers.getPartNetworkChecked(network);
        S partState = getPartState(blockState);
        partNetwork.removePart(partState.getId());
        part.onNetworkRemoval(network, partNetwork, getTarget(partState), partState);
    }

    @Override
    public void onPreRemoved(INetwork network) {
        part.onPreRemoved(network, NetworkHelpers.getPartNetworkChecked(network), getTarget(), (tempState = getPartState()));
    }

    @Override
    public void onPostRemoved(INetwork network) {
        part.onPostRemoved(network, NetworkHelpers.getPartNetworkChecked(network), getTarget(tempState), Objects.requireNonNull(tempState));
        tempState = null;
    }

    @Override
    public void onNeighborBlockChange(@Nullable INetwork network, BlockGetter world, Block neighbourBlock,
                                      BlockPos neighbourBlockPos) {
        part.onBlockNeighborChange(network, NetworkHelpers.getPartNetworkChecked(network), getTarget(), getPartState(), world,
                neighbourBlock, neighbourBlockPos);
    }

    @Override
    public Optional<P> getNetworkEventListener() {
        return Optional.of(getPart());
    }

    public boolean equals(Object o) {
        return o instanceof IPartNetworkElement && compareTo((INetworkElement) o) == 0;
    }

    @Override
    public int hashCode() {
        int result = part.hashCode();
        result = 31 * result + this.center.hashCode();
        return result;
    }

    @Override
    public int compareTo(INetworkElement o) {
        if (o instanceof IPartNetworkElement) {
            IPartNetworkElement p = (IPartNetworkElement) o;
            int compClass = this.getPart().getUniqueName().compareTo(p.getPart().getUniqueName());
            if (compClass == 0) {
                // If this or the other part is not loaded, we IGNORE the priority,
                // because that depends on tile entity data, which requires loading the part/chunk.
                int compPriority = !isLoaded() || !p.isLoaded() ? 0 : -Integer.compare(this.getPriority(), p.getPriority());
                if (compPriority == 0) {
                    int compPart = getPart().getTranslationKey().compareTo(p.getPart().getTranslationKey());
                    if (compPart == 0) {
                        int compPos = this.center.getPos().compareTo(p.getPosition());
                        if (compPos == 0) {
                            return this.center.getSide().compareTo(p.getSide());
                        }
                        return compPos;
                    }
                    return compPart;
                } else {
                    return compPriority;
                }
            } else {
                return compClass;
            }
        }

        return this.getClass().getName().compareTo(o.getClass().getName());
    }

    @Override
    public DimPos getPosition() {
        return this.center.getPos();
    }

    @Override
    public Direction getSide() {
        return this.center.getSide();
    }

    @Override
    public int getId() {
        if (!hasPartState()) {
            return -1;
        }
        return getPartState().getId();
    }

    @Override
    public ResourceLocation getGroup() {
        return IPartNetworkElement.GROUP;
    }
}

1	package org.cyclops.integrateddynamics.core.network;
2
3	import net.minecraft.core.BlockPos;
4	import net.minecraft.core.Direction;
5	import net.minecraft.resources.ResourceLocation;
6	import net.minecraft.world.item.ItemStack;
7	import net.minecraft.world.level.BlockGetter;
8	import net.minecraft.world.level.block.Block;
9	import net.minecraft.world.level.block.state.BlockState;
10	import org.cyclops.cyclopscore.datastructure.DimPos;
11	import org.cyclops.integrateddynamics.api.PartStateException;
12	import org.cyclops.integrateddynamics.api.network.*;
13	import org.cyclops.integrateddynamics.api.part.*;
14	import org.cyclops.integrateddynamics.core.helper.NetworkHelpers;
15	import org.cyclops.integrateddynamics.core.helper.PartHelpers;
16
17	import javax.annotation.Nullable;
18	import java.util.List;
19	import java.util.Objects;
20	import java.util.Optional;
21
22	/**
23	* A network element for parts.
24	* @author rubensworks
25	*/
26	public class PartNetworkElement<P extends IPartType<P, S>, S extends IPartState<P>> extends NetworkElementBase
27	implements IPartNetworkElement<P, S>, IEnergyConsumingNetworkElement {
28
29	private final P part;
30	private final PartPos center;
31
32	private S tempState = null;	3✔
33
34	public PartNetworkElement(P part, PartPos center) {	2✔
35	this.part = part;	3✔
36	this.center = center;	3✔
37	}	1✔
38
39	protected static DimPos getCenterPos(PartTarget target) {
40	return target.getCenter().getPos();	×
41	}
42
43	protected static Direction getCenterSide(PartTarget target) {
44	return target.getCenter().getSide();	×
45	}
46
47	protected static DimPos getTargetPos(PartTarget target) {
48	return target.getTarget().getPos();	×
49	}
50
51	protected static Direction getTargetSide(PartTarget target) {
52	return target.getTarget().getSide();	×
53	}
54
55	@Override
56	public P getPart() {
57	return part;	3✔
58	}
59
60	@Override
61	public PartTarget getTarget() {
62	return getPart().getTarget(this.center, getPartState());	8✔
63	}
64
65	public PartTarget getTarget(S partState) {
66	return getPart().getTarget(this.center, partState);	7✔
67	}
68
69	public S getTempState() {
70	return tempState;	×
71	}
72
73	public void setTempState(S tempState) {
74	this.tempState = tempState;	×
75	}	×
76
77	@Override
78	public IPartContainer getPartContainer() {
79	return PartHelpers.getPartContainerChecked(this.center.getPos(), this.center.getSide());	8✔
80	}
81
82	public IPartContainer getPartContainer(BlockState blockState) {
83	return PartHelpers.getPartContainerChecked(this.center.getPos(), this.center.getSide(), blockState);	9✔
84	}
85
86	public Optional<IPartContainer> getPartContainerOptional() {
87	return PartHelpers.getPartContainer(this.center.getPos(), this.center.getSide());	8✔
88	}
89
90	@Override
91	public void setPriorityAndChannel(INetwork network, int priority, int channel) {
92	//noinspection deprecation
93	part.setPriorityAndChannel(network, NetworkHelpers.getPartNetworkChecked(network), getTarget(), getPartState(), priority, channel);	×
94	}	×
95
96	@Override
97	public int getPriority() {
98	return hasPartState() ? part.getPriority(getPartState()) : 0;	11✔
99	}
100
101	@Override
102	public int getChannel() {
103	return hasPartState() ? part.getChannel(getPartState()) : IPositionedAddonsNetwork.DEFAULT_CHANNEL;	×
104	}
105
106	@Override
107	public boolean canRevalidate(INetwork network) {
108	return canRevalidatePositioned(network, this.center.getPos());	7✔
109	}
110
111	@Override
112	public void revalidate(INetwork network) {
113	super.revalidate(network);	×
114	if (revalidatePositioned(network, this.center.getPos())) {	×
115	part.afterNetworkReAlive(network, NetworkHelpers.getPartNetworkChecked(network), PartTarget.fromCenter(this.center), getPartState());	×
116	}
117	}	×
118
119	@Override
120	public boolean isLoaded() {
121	return INetworkElement.shouldTick(this.center.getPos());	5✔
122	}
123
124	public boolean hasPartState() {
125	if (isLoaded()) {	3!
126	return getPartContainerOptional()	5✔
127	.map(partContainer -> partContainer.hasPart(this.center.getSide()))	9✔
128	.orElse(false);	4✔
129	}
130	return false;	×
131	}
132
133	@Override
134	public S getPartState() throws PartStateException {
135	IPartContainer partContainer = getPartContainer();	3✔
136	if(partContainer != null) {	2!
137	return (S) partContainer.getPartState(this.center.getSide());	6✔
138	} else {
139	throw new PartStateException(this.center.getPos(), this.center.getSide());	×
140	}
141	}
142
143	public S getPartState(BlockState blockState) throws PartStateException {
144	IPartContainer partContainer = getPartContainer(blockState);	4✔
145	if(partContainer != null) {	2!
146	return (S) partContainer.getPartState(this.center.getSide());	6✔
147	} else {
148	throw new PartStateException(this.center.getPos(), this.center.getSide());	×
149	}
150	}
151
152	@Override
153	public int getConsumptionRate() {
154	return getPart().getConsumptionRate(getPartState());	6✔
155	}
156
157	@Override
158	public void postUpdate(INetwork network, boolean updated) {
159	part.postUpdate(network, NetworkHelpers.getPartNetworkChecked(network), getTarget(), getPartState(), updated);	11✔
160	}	1✔
161
162	@Override
163	public int getUpdateInterval() {
164	return part.getUpdateInterval(getPartState());	6✔
165	}
166
167	@Override
168	public boolean isUpdate() {
169	return part.isUpdate(getPartState());	6✔
170	}
171
172	@Override
173	public void update(INetwork network) {
174	part.update(network, NetworkHelpers.getPartNetworkChecked(network), getTarget(), getPartState());	10✔
175	}	1✔
176
177	@Override
178	public void beforeNetworkKill(INetwork network) {
179	part.beforeNetworkKill(network, NetworkHelpers.getPartNetworkChecked(network), getTarget(), getPartState());	×
180	}	×
181
182	@Override
183	public void beforeNetworkKill(INetwork network, BlockState blockState) {
184	S partState = getPartState(blockState);	4✔
185	part.beforeNetworkKill(network, NetworkHelpers.getPartNetworkChecked(network), getTarget(partState), partState);	10✔
186	}	1✔
187
188	@Override
189	public void afterNetworkAlive(INetwork network) {
190	part.afterNetworkAlive(network, NetworkHelpers.getPartNetworkChecked(network), getTarget(), getPartState());	10✔
191	}	1✔
192
193	@Override
194	public void afterNetworkReAlive(INetwork network) {
195	part.afterNetworkReAlive(network, NetworkHelpers.getPartNetworkChecked(network), getTarget(), getPartState());	10✔
196	}	1✔
197
198	@Override
199	public void addDrops(List<ItemStack> itemStacks, boolean dropMainElement, boolean saveState) {
200	part.addDrops(getTarget(), getPartState(), itemStacks, dropMainElement, saveState);	10✔
201	}	1✔
202
203	@Override
204	public void addDrops(BlockState blockState, List<ItemStack> itemStacks, boolean dropMainElement, boolean saveState) {
205	S partState = getPartState(blockState);	4✔
206	part.addDrops(getTarget(partState), partState, itemStacks, dropMainElement, saveState);	10✔
207	}	1✔
208
209	@Override
210	public boolean onNetworkAddition(INetwork network) {
211	IPartNetwork partNetwork = NetworkHelpers.getPartNetworkChecked(network);	3✔
212	boolean res = partNetwork.addPart(getPartState().getId(), this.center);	8✔
213	if(res) {	2!
214	part.onNetworkAddition(network, partNetwork, getTarget(), getPartState());	9✔
215	}
216	return res;	2✔
217	}
218
219	@Override
220	public void onNetworkRemoval(INetwork network) {
221	IPartNetwork partNetwork = NetworkHelpers.getPartNetworkChecked(network);	×
222	partNetwork.removePart(getPartState().getId());	×
223	part.onNetworkRemoval(network, partNetwork, getTarget(), getPartState());	×
224	}	×
225
226	@Override
227	public void onNetworkRemoval(INetwork network, BlockState blockState) {
228	IPartNetwork partNetwork = NetworkHelpers.getPartNetworkChecked(network);	3✔
229	S partState = getPartState(blockState);	4✔
230	partNetwork.removePart(partState.getId());	4✔
231	part.onNetworkRemoval(network, partNetwork, getTarget(partState), partState);	9✔
232	}	1✔
233
234	@Override
235	public void onPreRemoved(INetwork network) {
236	part.onPreRemoved(network, NetworkHelpers.getPartNetworkChecked(network), getTarget(), (tempState = getPartState()));	13✔
237	}	1✔
238
239	@Override
240	public void onPostRemoved(INetwork network) {
241	part.onPostRemoved(network, NetworkHelpers.getPartNetworkChecked(network), getTarget(tempState), Objects.requireNonNull(tempState));	14✔
242	tempState = null;	3✔
243	}	1✔
244
245	@Override
246	public void onNeighborBlockChange(@Nullable INetwork network, BlockGetter world, Block neighbourBlock,
247	BlockPos neighbourBlockPos) {
248	part.onBlockNeighborChange(network, NetworkHelpers.getPartNetworkChecked(network), getTarget(), getPartState(), world,	13✔
249	neighbourBlock, neighbourBlockPos);
250	}	1✔
251
252	@Override
253	public Optional<P> getNetworkEventListener() {
254	return Optional.of(getPart());	4✔
255	}
256
257	public boolean equals(Object o) {
258	return o instanceof IPartNetworkElement && compareTo((INetworkElement) o) == 0;	11!
259	}
260
261	@Override
262	public int hashCode() {
263	int result = part.hashCode();	4✔
264	result = 31 * result + this.center.hashCode();	8✔
265	return result;	2✔
266	}
267
268	@Override
269	public int compareTo(INetworkElement o) {
270	if (o instanceof IPartNetworkElement) {	3✔
271	IPartNetworkElement p = (IPartNetworkElement) o;	3✔
272	int compClass = this.getPart().getUniqueName().compareTo(p.getPart().getUniqueName());	8✔
273	if (compClass == 0) {	2✔
274	// If this or the other part is not loaded, we IGNORE the priority,
275	// because that depends on tile entity data, which requires loading the part/chunk.
276	int compPriority = !isLoaded() \|\| !p.isLoaded() ? 0 : -Integer.compare(this.getPriority(), p.getPriority());	15✔
277	if (compPriority == 0) {	2!
278	int compPart = getPart().getTranslationKey().compareTo(p.getPart().getTranslationKey());	8✔
279	if (compPart == 0) {	2!
280	int compPos = this.center.getPos().compareTo(p.getPosition());	7✔
281	if (compPos == 0) {	2✔
282	return this.center.getSide().compareTo(p.getSide());	7✔
283	}
284	return compPos;	2✔
285	}
286	return compPart;	×
287	} else {
288	return compPriority;	×
289	}
290	} else {
291	return compClass;	2✔
292	}
293	}
294
295	return this.getClass().getName().compareTo(o.getClass().getName());	8✔
296	}
297
298	@Override
299	public DimPos getPosition() {
300	return this.center.getPos();	4✔
301	}
302
303	@Override
304	public Direction getSide() {
305	return this.center.getSide();	4✔
306	}
307
308	@Override
309	public int getId() {
310	if (!hasPartState()) {	×
311	return -1;	×
312	}
313	return getPartState().getId();	×
314	}
315
316	@Override
317	public ResourceLocation getGroup() {
318	return IPartNetworkElement.GROUP;	×
319	}
320	}

CyclopsMC / IntegratedDynamics / 20820179538

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