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

6.9

/src/main/java/org/cyclops/integrateddynamics/core/part/read/PartTypeReadBase.java

package org.cyclops.integrateddynamics.core.part.read;

import com.google.common.collect.Sets;
import net.minecraft.core.Direction;
import net.minecraft.core.Vec3i;
import net.minecraft.network.RegistryFriendlyByteBuf;
import net.minecraft.network.chat.Component;
import net.minecraft.server.level.ServerPlayer;
import net.minecraft.world.MenuProvider;
import net.minecraft.world.SimpleContainer;
import net.minecraft.world.entity.player.Inventory;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.inventory.AbstractContainerMenu;
import net.minecraft.world.level.BlockGetter;
import org.apache.commons.lang3.tuple.Triple;
import org.cyclops.cyclopscore.network.PacketCodecs;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValue;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValueType;
import org.cyclops.integrateddynamics.api.network.INetwork;
import org.cyclops.integrateddynamics.api.network.IPartNetwork;
import org.cyclops.integrateddynamics.api.part.IPartContainer;
import org.cyclops.integrateddynamics.api.part.PartPos;
import org.cyclops.integrateddynamics.api.part.PartRenderPosition;
import org.cyclops.integrateddynamics.api.part.PartTarget;
import org.cyclops.integrateddynamics.api.part.aspect.AspectUpdateType;
import org.cyclops.integrateddynamics.api.part.aspect.IAspect;
import org.cyclops.integrateddynamics.api.part.aspect.IAspectRead;
import org.cyclops.integrateddynamics.api.part.aspect.IAspectVariable;
import org.cyclops.integrateddynamics.api.part.read.IPartStateReader;
import org.cyclops.integrateddynamics.api.part.read.IPartTypeReader;
import org.cyclops.integrateddynamics.core.helper.PartHelpers;
import org.cyclops.integrateddynamics.core.part.PartTypeAspects;
import org.cyclops.integrateddynamics.core.part.PartTypeBase;
import org.cyclops.integrateddynamics.inventory.container.ContainerPartReader;
import org.cyclops.integrateddynamics.part.aspect.Aspects;

import javax.annotation.Nullable;
import java.util.EnumMap;
import java.util.List;
import java.util.Optional;
import java.util.Set;

/**
 * An abstract {@link IPartTypeReader}.
 * @author rubensworks
 */
public abstract class PartTypeReadBase<P extends IPartTypeReader<P, S>, S extends IPartStateReader<P>>
        extends PartTypeAspects<P, S> implements IPartTypeReader<P, S> {

    private List<IAspectRead<?, ?>> aspectsRead = null;
    private EnumMap<AspectUpdateType, Set<IAspectRead<?, ?>>> updateAspects = null;

    public PartTypeReadBase(String name) {
        this(name, new PartRenderPosition(0.1875F, 0.3125F, 0.625F, 0.625F));
    }

    public PartTypeReadBase(String name, PartRenderPosition partRenderPosition) {
        super(name, partRenderPosition);
    }

    protected Set<IAspectRead<?, ?>> getUpdateAspects(AspectUpdateType updateType) {
        if (updateAspects == null) {
            updateAspects = new EnumMap<>(AspectUpdateType.class);
            for (AspectUpdateType aspectUpdateType : AspectUpdateType.values()) {
                updateAspects.put(aspectUpdateType, Sets.newLinkedHashSet());
            }
            for (IAspect aspect : getAspects()) {
                if (aspect instanceof IAspectRead) {
                    IAspectRead aspectRead = (IAspectRead) aspect;
                    updateAspects.get(aspectRead.getUpdateType()).add(aspectRead);
                }
            }
        }

        return updateAspects.get(updateType);
    }

    @Override
    public boolean isSolid(S state) {
        return true;
    }

    @Override
    public void update(INetwork network, IPartNetwork partNetwork, PartTarget target, S state) {
        for(IAspect aspect : getUpdateAspects(AspectUpdateType.NETWORK_TICK)) {
            aspect.update(network, partNetwork, this, target, state);
        }

        // Special case: if we have an offset, also update block-update-based aspects, because we can't rely on just block updates.
        if (this.getTargetOffset(state).compareTo(Vec3i.ZERO) != 0) {
            for(IAspect aspect : getUpdateAspects(AspectUpdateType.BLOCK_UPDATE)) {
                aspect.update(network, partNetwork, this, target, state);
            }
        }

        // We call super as last because super will invoke the offset handler, which can cause the PartTarget to change.
        // This PartTarget change can conflict with aspects, and cause weird delay problems, such as #1320,
        // So that's why we delay it so it only applies for the next tick.
        super.update(network, partNetwork, target, state);
    }

    @Override
    public void onBlockNeighborChange(INetwork network, IPartNetwork partNetwork, PartTarget target, S state,
                                      BlockGetter world, @Nullable Direction side) {
        super.onBlockNeighborChange(network, partNetwork, target, state, world, side);
        for(IAspect aspect : getUpdateAspects(AspectUpdateType.BLOCK_UPDATE)) {
            aspect.update(network, partNetwork, this, target, state);
        }
    }

    @Override
    public List<IAspectRead<?, ?>> getReadAspects() {
        if (aspectsRead == null) {
            aspectsRead = Aspects.REGISTRY.getReadAspects(this);
        }
        return aspectsRead;
    }

    @Override
    public <V extends IValue, T extends IValueType<V>> IAspectVariable<V> getVariable(PartTarget target, S partState,
                                                                                      IAspectRead<V, T> aspect) {
        IAspectVariable<V> variable = partState.getVariable(aspect);
        if(variable == null) {
            if(!getAspects().contains(aspect)) {
                throw new IllegalArgumentException(String.format("Tried to get the variable for the aspect %s that did not exist within the " +
                        "part type %s.", aspect.getUniqueName(), this));
            }
            variable = aspect.createNewVariable(() -> getTarget(target.getCenter(), partState));
            partState.setVariable(aspect, variable);
        }
        return variable;
    }

    @Override
    public boolean setTargetOffset(S state, PartPos center, Vec3i offset) {
        Vec3i lastOffset = getTargetOffset(state);
        boolean ret = super.setTargetOffset(state, center, offset);
        if (!lastOffset.equals(offset)) {
            state.resetVariables();
        }
        return ret;
    }

    @Override
    public void setTargetSideOverride(S state, @Nullable Direction side) {
        Direction lastSide = getTargetSideOverride(state);
        super.setTargetSideOverride(state, side);
        if (lastSide != side) {
            state.resetVariables();
        }
    }

    @Override
    public Optional<MenuProvider> getContainerProvider(PartPos pos) {
        return Optional.of(new MenuProvider() {
            @Override
            public Component getDisplayName() {
                return Component.translatable(getTranslationKey());
            }

            @Nullable
            @Override
            public AbstractContainerMenu createMenu(int id, Inventory playerInventory, Player playerEntity) {
                Triple<IPartContainer, PartTypeBase, PartTarget> data = PartHelpers.getContainerPartConstructionData(pos);
                return new ContainerPartReader<>(id, playerInventory, new SimpleContainer(0),
                        data.getRight(), Optional.of(data.getLeft()), (PartTypeReadBase) data.getMiddle());
            }

            @Override
            public boolean shouldTriggerClientSideContainerClosingOnOpen() {
                return false;
            }
        });
    }

    @Override
    public void writeExtraGuiData(RegistryFriendlyByteBuf packetBuffer, PartPos pos, ServerPlayer player) {
        // Write part position
        PacketCodecs.write(packetBuffer, pos);

        super.writeExtraGuiData(packetBuffer, pos, player);
    }

}

1	package org.cyclops.integrateddynamics.core.part.read;
2
3	import com.google.common.collect.Sets;
4	import net.minecraft.core.Direction;
5	import net.minecraft.core.Vec3i;
6	import net.minecraft.network.RegistryFriendlyByteBuf;
7	import net.minecraft.network.chat.Component;
8	import net.minecraft.server.level.ServerPlayer;
9	import net.minecraft.world.MenuProvider;
10	import net.minecraft.world.SimpleContainer;
11	import net.minecraft.world.entity.player.Inventory;
12	import net.minecraft.world.entity.player.Player;
13	import net.minecraft.world.inventory.AbstractContainerMenu;
14	import net.minecraft.world.level.BlockGetter;
15	import org.apache.commons.lang3.tuple.Triple;
16	import org.cyclops.cyclopscore.network.PacketCodecs;
17	import org.cyclops.integrateddynamics.api.evaluate.variable.IValue;
18	import org.cyclops.integrateddynamics.api.evaluate.variable.IValueType;
19	import org.cyclops.integrateddynamics.api.network.INetwork;
20	import org.cyclops.integrateddynamics.api.network.IPartNetwork;
21	import org.cyclops.integrateddynamics.api.part.IPartContainer;
22	import org.cyclops.integrateddynamics.api.part.PartPos;
23	import org.cyclops.integrateddynamics.api.part.PartRenderPosition;
24	import org.cyclops.integrateddynamics.api.part.PartTarget;
25	import org.cyclops.integrateddynamics.api.part.aspect.AspectUpdateType;
26	import org.cyclops.integrateddynamics.api.part.aspect.IAspect;
27	import org.cyclops.integrateddynamics.api.part.aspect.IAspectRead;
28	import org.cyclops.integrateddynamics.api.part.aspect.IAspectVariable;
29	import org.cyclops.integrateddynamics.api.part.read.IPartStateReader;
30	import org.cyclops.integrateddynamics.api.part.read.IPartTypeReader;
31	import org.cyclops.integrateddynamics.core.helper.PartHelpers;
32	import org.cyclops.integrateddynamics.core.part.PartTypeAspects;
33	import org.cyclops.integrateddynamics.core.part.PartTypeBase;
34	import org.cyclops.integrateddynamics.inventory.container.ContainerPartReader;
35	import org.cyclops.integrateddynamics.part.aspect.Aspects;
36
37	import javax.annotation.Nullable;
38	import java.util.EnumMap;
39	import java.util.List;
40	import java.util.Optional;
41	import java.util.Set;
42
43	/**
44	* An abstract {@link IPartTypeReader}.
45	* @author rubensworks
46	*/
47	public abstract class PartTypeReadBase<P extends IPartTypeReader<P, S>, S extends IPartStateReader<P>>
48	extends PartTypeAspects<P, S> implements IPartTypeReader<P, S> {
49
50	private List<IAspectRead<?, ?>> aspectsRead = null;	3✔
51	private EnumMap<AspectUpdateType, Set<IAspectRead<?, ?>>> updateAspects = null;	3✔
52
53	public PartTypeReadBase(String name) {
54	this(name, new PartRenderPosition(0.1875F, 0.3125F, 0.625F, 0.625F));	10✔
55	}	1✔
56
57	public PartTypeReadBase(String name, PartRenderPosition partRenderPosition) {
58	super(name, partRenderPosition);	4✔
59	}	1✔
60
61	protected Set<IAspectRead<?, ?>> getUpdateAspects(AspectUpdateType updateType) {
62	if (updateAspects == null) {	×
63	updateAspects = new EnumMap<>(AspectUpdateType.class);	×
64	for (AspectUpdateType aspectUpdateType : AspectUpdateType.values()) {	×
65	updateAspects.put(aspectUpdateType, Sets.newLinkedHashSet());	×
66	}
67	for (IAspect aspect : getAspects()) {	×
68	if (aspect instanceof IAspectRead) {	×
69	IAspectRead aspectRead = (IAspectRead) aspect;	×
70	updateAspects.get(aspectRead.getUpdateType()).add(aspectRead);	×
71	}
72	}	×
73	}
74
75	return updateAspects.get(updateType);	×
76	}
77
78	@Override
79	public boolean isSolid(S state) {
80	return true;	×
81	}
82
83	@Override
84	public void update(INetwork network, IPartNetwork partNetwork, PartTarget target, S state) {
85	for(IAspect aspect : getUpdateAspects(AspectUpdateType.NETWORK_TICK)) {	×
86	aspect.update(network, partNetwork, this, target, state);	×
87	}	×
88
89	// Special case: if we have an offset, also update block-update-based aspects, because we can't rely on just block updates.
90	if (this.getTargetOffset(state).compareTo(Vec3i.ZERO) != 0) {	×
91	for(IAspect aspect : getUpdateAspects(AspectUpdateType.BLOCK_UPDATE)) {	×
92	aspect.update(network, partNetwork, this, target, state);	×
93	}	×
94	}
95
96	// We call super as last because super will invoke the offset handler, which can cause the PartTarget to change.
97	// This PartTarget change can conflict with aspects, and cause weird delay problems, such as #1320,
98	// So that's why we delay it so it only applies for the next tick.
99	super.update(network, partNetwork, target, state);	×
100	}	×
101
102	@Override
103	public void onBlockNeighborChange(INetwork network, IPartNetwork partNetwork, PartTarget target, S state,
104	BlockGetter world, @Nullable Direction side) {
105	super.onBlockNeighborChange(network, partNetwork, target, state, world, side);	×
106	for(IAspect aspect : getUpdateAspects(AspectUpdateType.BLOCK_UPDATE)) {	×
107	aspect.update(network, partNetwork, this, target, state);	×
108	}	×
109	}	×
110
111	@Override
112	public List<IAspectRead<?, ?>> getReadAspects() {
113	if (aspectsRead == null) {	×
114	aspectsRead = Aspects.REGISTRY.getReadAspects(this);	×
115	}
116	return aspectsRead;	×
117	}
118
119	@Override
120	public <V extends IValue, T extends IValueType<V>> IAspectVariable<V> getVariable(PartTarget target, S partState,
121	IAspectRead<V, T> aspect) {
122	IAspectVariable<V> variable = partState.getVariable(aspect);	×
123	if(variable == null) {	×
124	if(!getAspects().contains(aspect)) {	×
125	throw new IllegalArgumentException(String.format("Tried to get the variable for the aspect %s that did not exist within the " +	×
126	"part type %s.", aspect.getUniqueName(), this));	×
127	}
128	variable = aspect.createNewVariable(() -> getTarget(target.getCenter(), partState));	×
129	partState.setVariable(aspect, variable);	×
130	}
131	return variable;	×
132	}
133
134	@Override
135	public boolean setTargetOffset(S state, PartPos center, Vec3i offset) {
136	Vec3i lastOffset = getTargetOffset(state);	×
137	boolean ret = super.setTargetOffset(state, center, offset);	×
138	if (!lastOffset.equals(offset)) {	×
139	state.resetVariables();	×
140	}
141	return ret;	×
142	}
143
144	@Override
145	public void setTargetSideOverride(S state, @Nullable Direction side) {
146	Direction lastSide = getTargetSideOverride(state);	×
147	super.setTargetSideOverride(state, side);	×
148	if (lastSide != side) {	×
149	state.resetVariables();	×
150	}
151	}	×
152
153	@Override
154	public Optional<MenuProvider> getContainerProvider(PartPos pos) {
155	return Optional.of(new MenuProvider() {	×
156	@Override
157	public Component getDisplayName() {
158	return Component.translatable(getTranslationKey());	×
159	}
160
161	@Nullable
162	@Override
163	public AbstractContainerMenu createMenu(int id, Inventory playerInventory, Player playerEntity) {
164	Triple<IPartContainer, PartTypeBase, PartTarget> data = PartHelpers.getContainerPartConstructionData(pos);	×
165	return new ContainerPartReader<>(id, playerInventory, new SimpleContainer(0),	×
166	data.getRight(), Optional.of(data.getLeft()), (PartTypeReadBase) data.getMiddle());	×
167	}
168
169	@Override
170	public boolean shouldTriggerClientSideContainerClosingOnOpen() {
171	return false;	×
172	}
173	});
174	}
175
176	@Override
177	public void writeExtraGuiData(RegistryFriendlyByteBuf packetBuffer, PartPos pos, ServerPlayer player) {
178	// Write part position
179	PacketCodecs.write(packetBuffer, pos);	×
180
181	super.writeExtraGuiData(packetBuffer, pos, player);	×
182	}	×
183
184	}

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