14549182042

Committed 19 Apr 2025 12:35PM UTC coverage: 42.579% (+0.004%) from 42.575%

Build # 14549182042

Build Type

push

github

Committed by

rubensworks

Commit Message

Fix wrench not removing cables after using off-hand item, Closes #1504

Run Details

2310 of 8383 branches covered (27.56%)

Branch coverage included in aggregate %.

11021 of 22926 relevant lines covered (48.07%)

2.26 hits per line

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

76.74

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

CyclopsMC / IntegratedDynamics / 14549182042

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