20210191346

Committed 14 Dec 2025 03:32PM UTC coverage: 19.514% (-33.5%) from 53.061%

Build # 20210191346

Build Type

push

github

Committed by

rubensworks

Commit Message

Remove deprecations

Run Details

663 of 8728 branches covered (7.6%)

Branch coverage included in aggregate %.

6786 of 29445 relevant lines covered (23.05%)

1.09 hits per line

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

0.0

/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.world.entity.player.Player;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.block.entity.BlockEntity;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.storage.ValueInput;
import net.minecraft.world.level.storage.ValueOutput;
import org.cyclops.cyclopscore.datastructure.DimPos;
import org.cyclops.cyclopscore.datastructure.EnumFacingMap;
import org.cyclops.cyclopscore.helper.IModHelpers;
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.*;
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(!IModHelpers.get().getMinecraftHelpers().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();
                BlockState blockState = getLevel().getBlockState(getPos());
                BlockEntity blockEntity = getLevel().getBlockEntity(getPos());
                networkElement.addDrops(blockState, blockEntity, itemStacks, dropMainElement, saveState);
                for(ItemStack itemStack : itemStacks) {
                    if(player != null) {
                        IModHelpers.get().getItemStackHelpers().spawnItemStackToPlayer(getLevel(), getPos(), itemStack, player);
                    } else {
                        IModHelpers.get().getItemStackHelpers().spawnItemStack(getLevel(), getPos(), itemStack);
                    }
                }

                // Remove the element from the network.
                getNetwork().removeNetworkElementPost(networkElement, blockState, blockEntity);

                // 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()), new PartPathElement(getPos()), partStateHolder.getState(), saveState);
                if(player != null) {
                    if (!player.isCreative()) {
                        IModHelpers.get().getItemStackHelpers().spawnItemStackToPlayer(getLevel(), getPos(), itemStack, player);
                    }
                } else {
                    IModHelpers.get().getItemStackHelpers().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 void toValueOutput(ValueOutput valueOutput) {
        PartHelpers.serializeParts(valueOutput, getPos(), this.partData);
    }

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

CyclopsMC / IntegratedDynamics / 20210191346

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