19640651880

Committed 24 Nov 2025 03:59PM UTC coverage: 44.824% (-0.3%) from 45.13%

Build # 19640651880

Build Type

push

github

Committed by

rubensworks

Commit Message

Bump mod version

Run Details

2581 of 8552 branches covered (30.18%)

Branch coverage included in aggregate %.

11789 of 23507 relevant lines covered (50.15%)

2.38 hits per line

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

72.18

/src/main/java/org/cyclops/integrateddynamics/capability/partcontainer/PartContainerDefault.java

package org.cyclops.integrateddynamics.capability.partcontainer;

import com.google.common.base.Function;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.core.HolderLookup;
import net.minecraft.nbt.CompoundTag;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.level.Level;
import org.cyclops.cyclopscore.datastructure.DimPos;
import org.cyclops.cyclopscore.datastructure.EnumFacingMap;
import org.cyclops.cyclopscore.helper.ItemStackHelpers;
import org.cyclops.cyclopscore.helper.MinecraftHelpers;
import org.cyclops.integrateddynamics.IntegratedDynamics;
import org.cyclops.integrateddynamics.api.PartStateException;
import org.cyclops.integrateddynamics.api.evaluate.variable.ValueDeseralizationContext;
import org.cyclops.integrateddynamics.api.network.INetwork;
import org.cyclops.integrateddynamics.api.network.INetworkElement;
import org.cyclops.integrateddynamics.api.network.IPartNetwork;
import org.cyclops.integrateddynamics.api.part.IPartContainer;
import org.cyclops.integrateddynamics.api.part.IPartState;
import org.cyclops.integrateddynamics.api.part.IPartType;
import org.cyclops.integrateddynamics.api.part.PartCapability;
import org.cyclops.integrateddynamics.api.part.PartTarget;
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.Map;
import java.util.Objects;
import java.util.Optional;

/**
 * Default implementation of an {@link IPartContainer}.
 * @author rubensworks
 */
public abstract class PartContainerDefault implements IPartContainer {

    protected final EnumFacingMap<PartHelpers.PartStateHolder<?, ?>> partData = EnumFacingMap.newMap();

    @Override
    public void update() {
        if(!MinecraftHelpers.isClientSideThread()) {
            // Loop over all part states to check their dirtiness
            for (PartHelpers.PartStateHolder<?, ?> partStateHolder : partData.values()) {
                if (partStateHolder.getState().isDirtyAndReset()) {
                    setChanged();
                }
                if (partStateHolder.getState().isUpdateAndReset()) {
                    sendUpdate();
                }
            }
        }
    }

    @Override
    public DimPos getPosition() {
        return DimPos.of(getLevel(), getPos());
    }

    @Override
    public Map<Direction, IPartType<?, ?>> getParts() {
        return Maps.transformValues(partData, new Function<PartHelpers.PartStateHolder<?, ?>, IPartType<?, ?>>() {
            @Nullable
            @Override
            public IPartType<?, ?> apply(@Nullable PartHelpers.PartStateHolder<?, ?> input) {
                return input.getPart();
            }
        });
    }

    @Override
    public boolean hasParts() {
        return !partData.isEmpty();
    }

    @Override
    public <P extends IPartType<P, S>, S extends IPartState<P>> boolean canAddPart(Direction side, IPartType<P, S> part) {
        return !hasPart(side);
    }

    @Override
    public <P extends IPartType<P, S>, S extends IPartState<P>>void setPart(final Direction side, final IPartType<P, S> part, final IPartState<P> partState) {
        PartHelpers.setPart(getNetwork(), getLevel(), getPos(), side, Objects.requireNonNull(part),
                Objects.requireNonNull(partState), new PartHelpers.IPartStateHolderCallback() {
                    @Override
                    public void onSet(PartHelpers.PartStateHolder<?, ?> partStateHolder) {
                        partData.put(side, PartHelpers.PartStateHolder.of(part, partState));
                        sendUpdate();
                    }
                });
        onPartsChanged();
    }

    @Override
    public IPartType getPart(Direction side) {
        PartHelpers.PartStateHolder<?, ?> partStateHolder = partData.get(side);
        return partStateHolder != null ? partStateHolder.getPart() : null;
    }

    @Override
    public boolean hasPart(Direction side) {
        return partData.containsKey(side);
    }

    @Override
    public IPartType removePart(Direction side, Player player, boolean dropMainElement, boolean saveState) {
        PartHelpers.PartStateHolder<?, ?> partStateHolder = partData.get(side); // Don't remove the state just yet! We might need it in network removal.
        if(partStateHolder == null) {
            IntegratedDynamics.clog(org.apache.logging.log4j.Level.WARN, "Attempted to remove a part at a side where no part was.");
            return null;
        } else {
            IPartType removed = partStateHolder.getPart();
            if (getNetwork() != null) {
                INetworkElement networkElement = removed.createNetworkElement(this, getPosition(), side);
                networkElement.onPreRemoved(getNetwork());
                if(!getNetwork().removeNetworkElementPre(networkElement)) {
                    return null;
                }

                // Don't drop main element when in creative mode
                if(player != null && player.isCreative()) {
                    dropMainElement = false;
                }

                // Drop all parts types as item.
                List<ItemStack> itemStacks = Lists.newLinkedList();
                networkElement.addDrops(itemStacks, dropMainElement, saveState);
                for(ItemStack itemStack : itemStacks) {
                    if(player != null) {
                        ItemStackHelpers.spawnItemStackToPlayer(getLevel(), getPos(), itemStack, player);
                    } else {
                        ItemStackHelpers.spawnItemStack(getLevel(), getPos(), itemStack);
                    }
                }

                // Remove the element from the network.
                getNetwork().removeNetworkElementPost(networkElement, getLevel().getBlockState(getPos()));

                // Finally remove the part data from this part.
                IPartType ret = partData.remove(side).getPart();

                networkElement.onPostRemoved(getNetwork());

                onPartsChanged();
                return ret;
            } else if (dropMainElement) {
                ItemStack itemStack = removed.getItemStack(ValueDeseralizationContext.of(player.level()), partStateHolder.getState(), saveState);
                if(player != null) {
                    if (!player.isCreative()) {
                        ItemStackHelpers.spawnItemStackToPlayer(getLevel(), getPos(), itemStack, player);
                    }
                } else {
                    ItemStackHelpers.spawnItemStack(getLevel(), getPos(), itemStack);
                }
            }
            // Finally remove the part data from this part.
            IPartType ret = partData.remove(side).getPart();
            onPartsChanged();
            return ret;
        }
    }

    @Override
    public void setPartState(Direction side, IPartState partState) throws PartStateException {
        if(!hasPart(side)) {
            throw new PartStateException(getPosition(), side);
        }
        partData.put(side, PartHelpers.PartStateHolder.of(getPart(side), partState));
        onPartsChanged();
    }

    @Override
    public IPartState getPartState(Direction side) throws PartStateException {
        synchronized (partData) {
            PartHelpers.PartStateHolder<?, ?> partStateHolder = partData.get(side);
            if (partStateHolder == null) {
                throw new PartStateException(getPosition(), side);
            }
            return partStateHolder.getState();
        }
    }

    @Override
    public <T> Optional<T> getCapability(PartCapability<T> partCapability, INetwork network, IPartNetwork partNetwork, PartTarget target) {
        if (hasPart(target.getCenter().getSide())) {
            IPartState partState = getPartState(target.getCenter().getSide());
            if (partState != null) {
                return partState.getCapability(
                        getPart(target.getCenter().getSide()),
                        partCapability,
                        network,
                        partNetwork,
                        target
                );
            }
        }
        return Optional.empty();
    }

    @Override
    public CompoundTag serializeNBT(HolderLookup.Provider provider) {
        CompoundTag tag = new CompoundTag();
        PartHelpers.writePartsToNBT(ValueDeseralizationContext.of(provider), getPos(), tag, this.partData);
        return tag;
    }

    @Override
    public void deserializeNBT(HolderLookup.Provider provider, CompoundTag tag) {
        synchronized (this.partData) {
            PartHelpers.readPartsFromNBT(getNetwork(), getPos(), tag, this.partData, getLevel());
        }
    }

    protected void onPartsChanged() {
        setChanged();
        sendUpdate();
    }

    protected abstract void setChanged();
    protected abstract void sendUpdate();
    protected abstract Level getLevel();
    protected abstract BlockPos getPos();
    protected abstract INetwork getNetwork();

    protected Optional<IPartNetwork> getPartNetwork() {
        return NetworkHelpers.getPartNetwork(getNetwork());
    }

    /**
     * @return The raw part data.
     */
    public EnumFacingMap<PartHelpers.PartStateHolder<?, ?>> getPartData() {
        return this.partData;
    }

    /**
     * Override the part data.
     * @param partData The raw part data.
     */
    public void setPartData(Map<Direction, PartHelpers.PartStateHolder<?, ?>> partData) {
        this.partData.clear();
        this.partData.putAll(partData);
    }

    /**
     * Reset the part data without signaling any neighbours or the network.
     * Is used in block conversion.
     */
    public void silentResetPartData() {
        this.partData.clear();
    }

}

1	package org.cyclops.integrateddynamics.capability.partcontainer;
2
3	import com.google.common.base.Function;
4	import com.google.common.collect.Lists;
5	import com.google.common.collect.Maps;
6	import net.minecraft.core.BlockPos;
7	import net.minecraft.core.Direction;
8	import net.minecraft.core.HolderLookup;
9	import net.minecraft.nbt.CompoundTag;
10	import net.minecraft.world.entity.player.Player;
11	import net.minecraft.world.item.ItemStack;
12	import net.minecraft.world.level.Level;
13	import org.cyclops.cyclopscore.datastructure.DimPos;
14	import org.cyclops.cyclopscore.datastructure.EnumFacingMap;
15	import org.cyclops.cyclopscore.helper.ItemStackHelpers;
16	import org.cyclops.cyclopscore.helper.MinecraftHelpers;
17	import org.cyclops.integrateddynamics.IntegratedDynamics;
18	import org.cyclops.integrateddynamics.api.PartStateException;
19	import org.cyclops.integrateddynamics.api.evaluate.variable.ValueDeseralizationContext;
20	import org.cyclops.integrateddynamics.api.network.INetwork;
21	import org.cyclops.integrateddynamics.api.network.INetworkElement;
22	import org.cyclops.integrateddynamics.api.network.IPartNetwork;
23	import org.cyclops.integrateddynamics.api.part.IPartContainer;
24	import org.cyclops.integrateddynamics.api.part.IPartState;
25	import org.cyclops.integrateddynamics.api.part.IPartType;
26	import org.cyclops.integrateddynamics.api.part.PartCapability;
27	import org.cyclops.integrateddynamics.api.part.PartTarget;
28	import org.cyclops.integrateddynamics.core.helper.NetworkHelpers;
29	import org.cyclops.integrateddynamics.core.helper.PartHelpers;
30
31	import javax.annotation.Nullable;
32	import java.util.List;
33	import java.util.Map;
34	import java.util.Objects;
35	import java.util.Optional;
36
37	/**
38	* Default implementation of an {@link IPartContainer}.
39	* @author rubensworks
40	*/
41	public abstract class PartContainerDefault implements IPartContainer {	2✔
42
43	protected final EnumFacingMap<PartHelpers.PartStateHolder<?, ?>> partData = EnumFacingMap.newMap();	4✔
44
45	@Override
46	public void update() {
47	if(!MinecraftHelpers.isClientSideThread()) {	2!
48	// Loop over all part states to check their dirtiness
49	for (PartHelpers.PartStateHolder<?, ?> partStateHolder : partData.values()) {	12✔
50	if (partStateHolder.getState().isDirtyAndReset()) {	4✔
51	setChanged();	2✔
52	}
53	if (partStateHolder.getState().isUpdateAndReset()) {	4✔
54	sendUpdate();	2✔
55	}
56	}	1✔
57	}
58	}	1✔
59
60	@Override
61	public DimPos getPosition() {
62	return DimPos.of(getLevel(), getPos());	6✔
63	}
64
65	@Override
66	public Map<Direction, IPartType<?, ?>> getParts() {
67	return Maps.transformValues(partData, new Function<PartHelpers.PartStateHolder<?, ?>, IPartType<?, ?>>() {	11✔
68	@Nullable
69	@Override
70	public IPartType<?, ?> apply(@Nullable PartHelpers.PartStateHolder<?, ?> input) {
71	return input.getPart();	3✔
72	}
73	});
74	}
75
76	@Override
77	public boolean hasParts() {
78	return !partData.isEmpty();	8✔
79	}
80
81	@Override
82	public <P extends IPartType<P, S>, S extends IPartState<P>> boolean canAddPart(Direction side, IPartType<P, S> part) {
83	return !hasPart(side);	7!
84	}
85
86	@Override
87	public <P extends IPartType<P, S>, S extends IPartState<P>>void setPart(final Direction side, final IPartType<P, S> part, final IPartState<P> partState) {
88	PartHelpers.setPart(getNetwork(), getLevel(), getPos(), side, Objects.requireNonNull(part),	13✔
89	Objects.requireNonNull(partState), new PartHelpers.IPartStateHolderCallback() {	24✔
90	@Override
91	public void onSet(PartHelpers.PartStateHolder<?, ?> partStateHolder) {
92	partData.put(side, PartHelpers.PartStateHolder.of(part, partState));	12✔
93	sendUpdate();	3✔
94	}	1✔
95	});
96	onPartsChanged();	2✔
97	}	1✔
98
99	@Override
100	public IPartType getPart(Direction side) {
101	PartHelpers.PartStateHolder<?, ?> partStateHolder = partData.get(side);	6✔
102	return partStateHolder != null ? partStateHolder.getPart() : null;	6!
103	}
104
105	@Override
106	public boolean hasPart(Direction side) {
107	return partData.containsKey(side);	5✔
108	}
109
110	@Override
111	public IPartType removePart(Direction side, Player player, boolean dropMainElement, boolean saveState) {
112	PartHelpers.PartStateHolder<?, ?> partStateHolder = partData.get(side); // Don't remove the state just yet! We might need it in network removal.	6✔
113	if(partStateHolder == null) {	2!
114	IntegratedDynamics.clog(org.apache.logging.log4j.Level.WARN, "Attempted to remove a part at a side where no part was.");	×
115	return null;	×
116	} else {
117	IPartType removed = partStateHolder.getPart();	3✔
118	if (getNetwork() != null) {	3✔
119	INetworkElement networkElement = removed.createNetworkElement(this, getPosition(), side);	7✔
120	networkElement.onPreRemoved(getNetwork());	4✔
121	if(!getNetwork().removeNetworkElementPre(networkElement)) {	5!
122	return null;	×
123	}
124
125	// Don't drop main element when in creative mode
126	if(player != null && player.isCreative()) {	5!
127	dropMainElement = false;	×
128	}
129
130	// Drop all parts types as item.
131	List<ItemStack> itemStacks = Lists.newLinkedList();	2✔
132	networkElement.addDrops(itemStacks, dropMainElement, saveState);	5✔
133	for(ItemStack itemStack : itemStacks) {	10✔
134	if(player != null) {	2!
135	ItemStackHelpers.spawnItemStackToPlayer(getLevel(), getPos(), itemStack, player);	8✔
136	} else {
137	ItemStackHelpers.spawnItemStack(getLevel(), getPos(), itemStack);	×
138	}
139	}	1✔
140
141	// Remove the element from the network.
142	getNetwork().removeNetworkElementPost(networkElement, getLevel().getBlockState(getPos()));	9✔
143
144	// Finally remove the part data from this part.
145	IPartType ret = partData.remove(side).getPart();	7✔
146
147	networkElement.onPostRemoved(getNetwork());	4✔
148
149	onPartsChanged();	2✔
150	return ret;	2✔
151	} else if (dropMainElement) {	2!
152	ItemStack itemStack = removed.getItemStack(ValueDeseralizationContext.of(player.level()), partStateHolder.getState(), saveState);	9✔
153	if(player != null) {	2!
154	if (!player.isCreative()) {	3!
155	ItemStackHelpers.spawnItemStackToPlayer(getLevel(), getPos(), itemStack, player);	8✔
156	}
157	} else {
158	ItemStackHelpers.spawnItemStack(getLevel(), getPos(), itemStack);	×
159	}
160	}
161	// Finally remove the part data from this part.
162	IPartType ret = partData.remove(side).getPart();	7✔
163	onPartsChanged();	2✔
164	return ret;	2✔
165	}
166	}
167
168	@Override
169	public void setPartState(Direction side, IPartState partState) throws PartStateException {
170	if(!hasPart(side)) {	×
171	throw new PartStateException(getPosition(), side);	×
172	}
173	partData.put(side, PartHelpers.PartStateHolder.of(getPart(side), partState));	×
174	onPartsChanged();	×
175	}	×
176
177	@Override
178	public IPartState getPartState(Direction side) throws PartStateException {
179	synchronized (partData) {	5✔
180	PartHelpers.PartStateHolder<?, ?> partStateHolder = partData.get(side);	6✔
181	if (partStateHolder == null) {	2!
182	throw new PartStateException(getPosition(), side);	×
183	}
184	return partStateHolder.getState();	5✔
185	}
186	}
187
188	@Override
189	public <T> Optional<T> getCapability(PartCapability<T> partCapability, INetwork network, IPartNetwork partNetwork, PartTarget target) {
190	if (hasPart(target.getCenter().getSide())) {	6✔
191	IPartState partState = getPartState(target.getCenter().getSide());	6✔
192	if (partState != null) {	2!
193	return partState.getCapability(	5✔
194	getPart(target.getCenter().getSide()),	7✔
195	partCapability,
196	network,
197	partNetwork,
198	target
199	);
200	}
201	}
202	return Optional.empty();	2✔
203	}
204
205	@Override
206	public CompoundTag serializeNBT(HolderLookup.Provider provider) {
207	CompoundTag tag = new CompoundTag();	4✔
208	PartHelpers.writePartsToNBT(ValueDeseralizationContext.of(provider), getPos(), tag, this.partData);	8✔
209	return tag;	2✔
210	}
211
212	@Override
213	public void deserializeNBT(HolderLookup.Provider provider, CompoundTag tag) {
214	synchronized (this.partData) {	×
215	PartHelpers.readPartsFromNBT(getNetwork(), getPos(), tag, this.partData, getLevel());	×
216	}	×
217	}	×
218
219	protected void onPartsChanged() {
220	setChanged();	2✔
221	sendUpdate();	2✔
222	}	1✔
223
224	protected abstract void setChanged();
225	protected abstract void sendUpdate();
226	protected abstract Level getLevel();
227	protected abstract BlockPos getPos();
228	protected abstract INetwork getNetwork();
229
230	protected Optional<IPartNetwork> getPartNetwork() {
231	return NetworkHelpers.getPartNetwork(getNetwork());	×
232	}
233
234	/**
235	* @return The raw part data.
236	*/
237	public EnumFacingMap<PartHelpers.PartStateHolder<?, ?>> getPartData() {
238	return this.partData;	3✔
239	}
240
241	/**
242	* Override the part data.
243	* @param partData The raw part data.
244	*/
245	public void setPartData(Map<Direction, PartHelpers.PartStateHolder<?, ?>> partData) {
246	this.partData.clear();	×
247	this.partData.putAll(partData);	×
248	}	×
249
250	/**
251	* Reset the part data without signaling any neighbours or the network.
252	* Is used in block conversion.
253	*/
254	public void silentResetPartData() {
255	this.partData.clear();	×
256	}	×
257
258	}

CyclopsMC / IntegratedDynamics / 19640651880

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