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/core/part/PartStateBase.java

package org.cyclops.integrateddynamics.core.part;

import com.google.common.collect.Maps;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
import net.minecraft.core.Direction;
import net.minecraft.core.NonNullList;
import net.minecraft.core.Vec3i;
import net.minecraft.network.chat.MutableComponent;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.world.ContainerHelper;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.level.storage.ValueInput;
import net.minecraft.world.level.storage.ValueOutput;
import net.neoforged.neoforge.common.NeoForge;
import org.cyclops.cyclopscore.persist.IDirtyMarkListener;
import org.cyclops.cyclopscore.persist.nbt.NBTClassType;
import org.cyclops.integrateddynamics.GeneralConfig;
import org.cyclops.integrateddynamics.IntegratedDynamics;
import org.cyclops.integrateddynamics.api.network.INetwork;
import org.cyclops.integrateddynamics.api.network.IPartNetwork;
import org.cyclops.integrateddynamics.api.part.*;
import org.cyclops.integrateddynamics.api.part.aspect.IAspect;
import org.cyclops.integrateddynamics.api.part.aspect.property.IAspectProperties;
import org.cyclops.integrateddynamics.core.evaluate.InventoryVariableEvaluator;
import org.cyclops.integrateddynamics.core.part.aspect.property.AspectProperties;
import org.cyclops.integrateddynamics.part.aspect.Aspects;

import javax.annotation.Nullable;
import java.util.IdentityHashMap;
import java.util.Map;
import java.util.Optional;

/**
 * A default implementation of the {@link IPartState}.
 * @author rubensworks
 */
public abstract class PartStateBase<P extends IPartType> implements IPartState<P>, IDirtyMarkListener {

    private boolean dirty = false;
    private boolean update = false;
    private boolean forceBlockUpdateRender = false;

    private int updateInterval = getDefaultUpdateInterval();
    private int priority = 0;
    private int channel = 0;
    private int maxOffset;
    private Vec3i targetOffset = new Vec3i(0, 0, 0);
    private Direction targetSide = null;
    private int id = -1;
    private Map<IAspect, IAspectProperties> aspectProperties = new IdentityHashMap<>();
    private boolean enabled = true;
    private final Map<String, NonNullList<ItemStack>> inventoriesNamed = Maps.newHashMap();
    private final PartStateOffsetHandler<P> offsetHandler = new PartStateOffsetHandler<>();

    private IdentityHashMap<PartCapability<?>, Optional<Object>> volatileCapabilities = new IdentityHashMap<>();

    @Override
    public void serialize(ValueOutput valueOutput) {
        valueOutput.putInt("updateInterval", this.updateInterval);
        valueOutput.putInt("priority", this.priority);
        valueOutput.putInt("channel", this.channel);
        if (this.targetSide != null) {
            valueOutput.putInt("targetSide", this.targetSide.ordinal());
        }
        valueOutput.putInt("id", this.id);
        writeAspectProperties(valueOutput.child("aspectProperties"));
        valueOutput.putBoolean("enabled", this.enabled);
        valueOutput.putInt("maxOffset", this.maxOffset);
        valueOutput.putInt("offsetX", this.targetOffset.getX());
        valueOutput.putInt("offsetY", this.targetOffset.getY());
        valueOutput.putInt("offsetZ", this.targetOffset.getZ());

        // Write inventoriesNamed
        ValueOutput.ValueOutputList namedInventoriesList = valueOutput.childrenList("inventoriesNamed");
        for (Map.Entry<String, NonNullList<ItemStack>> entry : this.inventoriesNamed.entrySet()) {
            ValueOutput listEntry = namedInventoriesList.addChild();
            listEntry.putString("tabName", entry.getKey());
            listEntry.putInt("itemCount", entry.getValue().size());
            ContainerHelper.saveAllItems(listEntry, entry.getValue());
        }

        ValueOutput.ValueOutputList errorsTag = valueOutput.childrenList("offsetVariablesSlotMessages");
        for (Int2ObjectMap.Entry<MutableComponent> entry : this.offsetHandler.offsetVariablesSlotMessages.int2ObjectEntrySet()) {
            ValueOutput child = errorsTag.addChild();
            String slot = String.valueOf(entry.getIntKey());
            child.putString("slot", slot);
            NBTClassType.writeNbt(MutableComponent.class, slot, entry.getValue(), child);
        }
    }

    @Override
    public void deserialize(ValueInput valueInput) {
        this.updateInterval = valueInput.getInt("updateInterval").orElseThrow();
        this.priority = valueInput.getInt("priority").orElseThrow();
        this.channel = valueInput.getInt("channel").orElseThrow();
        this.targetSide = valueInput.getInt("targetSide")
                .map(s -> Direction.values()[s])
                .orElse(null);
        this.id = valueInput.getInt("id").orElseThrow();
        this.aspectProperties.clear();
        readAspectProperties(valueInput.child("aspectProperties").orElseThrow());
        this.enabled = valueInput.getBooleanOr("enabled", false);
        this.maxOffset = valueInput.getInt("maxOffset").orElseThrow();
        this.targetOffset = new Vec3i(
                valueInput.getInt("offsetX").orElseThrow(),
                valueInput.getInt("offsetY").orElseThrow(),
                valueInput.getInt("offsetZ").orElseThrow()
        );

        // Read inventoriesNamed
        for (ValueInput listEntry : valueInput.childrenList("inventoriesNamed").orElseThrow()) {
            NonNullList<ItemStack> list = NonNullList.withSize(listEntry.getInt("itemCount").orElseThrow(), ItemStack.EMPTY);
            String tabName = listEntry.getString("tabName").orElseThrow();
            ContainerHelper.loadAllItems(listEntry, list);
            this.inventoriesNamed.put(tabName, list);
        }

        this.offsetHandler.offsetVariablesSlotMessages.clear();
        ValueInput.ValueInputList errorsTag = valueInput.childrenList("offsetVariablesSlotMessages").orElseThrow();
        for (ValueInput child : errorsTag) {
            String slot = child.getString("slot").orElseThrow();
            MutableComponent unlocalizedString = NBTClassType.readNbt(MutableComponent.class, slot, child);
            this.offsetHandler.offsetVariablesSlotMessages.put(Integer.parseInt(slot), unlocalizedString);
        }
    }

    protected void writeAspectProperties(ValueOutput valueOutput) {
        ValueOutput.ValueOutputList list = valueOutput.childrenList("map");
        for(Map.Entry<IAspect, IAspectProperties> entry : aspectProperties.entrySet()) {
            ValueOutput entryTag = list.addChild();
            entryTag.putString("key", entry.getKey().getUniqueName().toString());
            if(entry.getValue() != null) {
                entry.getValue().serialize(entryTag.child("value"));
            }
        }
    }

    public void readAspectProperties(ValueInput valueInput) {
        for (ValueInput entryTag : valueInput.childrenList("map").orElseThrow()) {
            IAspect key = Aspects.REGISTRY.getAspect(ResourceLocation.parse(entryTag.getString("key").orElseThrow()));
            IAspectProperties value = entryTag.child("value")
                    .map(v -> {
                        AspectProperties ap = new AspectProperties();
                        ap.deserialize(v);
                        return ap;
                    })
                    .orElse(null);
            if (key != null && value != null) {
                this.aspectProperties.put(key, value);
            }
        }
    }

    @Override
    public void generateId() {
        this.id = IntegratedDynamics.globalCounters.get().getNext(IPartState.GLOBALCOUNTER_KEY);
    }

    @Override
    public int getId() {
        return this.id;
    }

    @Override
    public void setUpdateInterval(int updateInterval) {
        this.updateInterval = updateInterval;
    }

    @Override
    public int getUpdateInterval() {
        return updateInterval;
    }

    @Override
    public void setPriority(int priority) {
        this.priority = priority;
    }

    @Override
    public int getPriority() {
        return priority;
    }

    @Override
    public void setChannel(int channel) {
        this.channel = channel;
    }

    @Override
    public int getChannel() {
        return channel;
    }

    @Override
    public Vec3i getTargetOffset() {
        return targetOffset;
    }

    @Override
    public void setTargetOffset(Vec3i targetOffset) {
        this.targetOffset = targetOffset;
        this.markDirty();
    }

    @Override
    public void setTargetSideOverride(Direction targetSide) {
        this.targetSide = targetSide;
    }

    @Nullable
    @Override
    public Direction getTargetSideOverride() {
        return targetSide;
    }

    @Override
    public void markDirty() {
        this.dirty = true;
    }

    @Override
    public boolean isDirtyAndReset() {
        boolean wasDirty = this.dirty;
        this.dirty = false;
        return wasDirty;
    }

    @Override
    public boolean isUpdateAndReset() {
        boolean wasUpdate = this.update;
        this.update = false;
        return wasUpdate;
    }

    @Override
    public void forceBlockRenderUpdate() {
        this.forceBlockUpdateRender = true;
    }

    @Override
    public boolean isForceBlockRenderUpdateAndReset() {
        boolean wasForceBlockUpdateRender = this.forceBlockUpdateRender;
        this.forceBlockUpdateRender = false;
        return wasForceBlockUpdateRender;
    }

    @Override
    public void onDirty() {
        this.dirty = true;
        this.forceBlockRenderUpdate();
    }

    /**
     * Enables a flag that tells the part container to send an NBT update to the client(s).
     */
    public void sendUpdate() {
        this.update = true;
    }

    @Override
    public IAspectProperties getAspectProperties(IAspect aspect) {
        return aspectProperties.get(aspect);
    }

    @Override
    public void setAspectProperties(IAspect aspect, IAspectProperties properties) {
        aspectProperties.put(aspect, properties);
        sendUpdate();
    }

    @Override
    public void setEnabled(boolean enabled) {
        boolean wasEnabled = this.enabled;
        this.enabled = enabled;
        if (this.enabled != wasEnabled) {
            sendUpdate();
        }
    }

    @Override
    public boolean isEnabled() {
        return enabled;
    }

    public NonNullList<ItemStack> getInventoryNamed(String name) {
        return this.inventoriesNamed.get(name);
    }

    public void setInventoryNamed(String name, NonNullList<ItemStack> inventory) {
        this.inventoriesNamed.put(name, inventory);
        onDirty();
    }

    @Override
    public Map<String, NonNullList<ItemStack>> getInventoriesNamed() {
        return this.inventoriesNamed;
    }

    @Override
    public void clearInventoriesNamed() {
        this.inventoriesNamed.clear();
    }

    /**
     * Gathers the capabilities of this part state.
     * Don't call this unless you know what you're doing!
     */
    public void gatherCapabilities(P partType) {
        AttachCapabilitiesEventPart event = new AttachCapabilitiesEventPart(partType, this);
        NeoForge.EVENT_BUS.post(event);
    }

    @Override
    public <T> Optional<T> getCapability(P partType, PartCapability<T> capability, INetwork network, IPartNetwork partNetwork, PartTarget target) {
        Optional<Object> o = volatileCapabilities.get(capability);
        if(o != null && o.isPresent()) {
            return (Optional<T>) o;
        }
        return Optional.ofNullable(capability.getCapability(partType, target));
    }

    @Override
    public <T> void addVolatileCapability(PartCapability<T> capability, Optional<T> value) {
        volatileCapabilities.put(capability, (Optional<Object>) value);
    }

    @Override
    public void removeVolatileCapability(PartCapability<?> capability) {
        volatileCapabilities.remove(capability);
    }

    protected int getDefaultUpdateInterval() {
        return GeneralConfig.defaultPartUpdateFreq;
    }

    @Override
    public void initializeOffsets(PartTarget target) {
        this.offsetHandler.initializeVariableEvaluators(this.offsetHandler.getOffsetVariablesInventory(this), target);
    }

    @Override
    public void updateOffsetVariables(P partType, INetwork network, IPartNetwork partNetwork, PartTarget target) {
        this.offsetHandler.updateOffsetVariables(partType, this, network, partNetwork, target);
    }

    @Nullable
    @Override
    public MutableComponent getOffsetVariableError(int slot) {
        return this.offsetHandler.getOffsetVariableError(slot);
    }

    @Override
    public boolean requiresOffsetUpdates() {
        return this.offsetHandler.offsetVariableEvaluators.stream().anyMatch(InventoryVariableEvaluator::hasVariable);
    }

    @Override
    public void markOffsetVariablesChanged() {
        this.offsetHandler.markOffsetVariablesChanged();
    }

    @Override
    public int getMaxOffset() {
        return maxOffset;
    }

    @Override
    public void setMaxOffset(int maxOffset) {
        this.maxOffset = maxOffset;
        markDirty();
    }
}

1	package org.cyclops.integrateddynamics.core.part;
2
3	import com.google.common.collect.Maps;
4	import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
5	import net.minecraft.core.Direction;
6	import net.minecraft.core.NonNullList;
7	import net.minecraft.core.Vec3i;
8	import net.minecraft.network.chat.MutableComponent;
9	import net.minecraft.resources.ResourceLocation;
10	import net.minecraft.world.ContainerHelper;
11	import net.minecraft.world.item.ItemStack;
12	import net.minecraft.world.level.storage.ValueInput;
13	import net.minecraft.world.level.storage.ValueOutput;
14	import net.neoforged.neoforge.common.NeoForge;
15	import org.cyclops.cyclopscore.persist.IDirtyMarkListener;
16	import org.cyclops.cyclopscore.persist.nbt.NBTClassType;
17	import org.cyclops.integrateddynamics.GeneralConfig;
18	import org.cyclops.integrateddynamics.IntegratedDynamics;
19	import org.cyclops.integrateddynamics.api.network.INetwork;
20	import org.cyclops.integrateddynamics.api.network.IPartNetwork;
21	import org.cyclops.integrateddynamics.api.part.*;
22	import org.cyclops.integrateddynamics.api.part.aspect.IAspect;
23	import org.cyclops.integrateddynamics.api.part.aspect.property.IAspectProperties;
24	import org.cyclops.integrateddynamics.core.evaluate.InventoryVariableEvaluator;
25	import org.cyclops.integrateddynamics.core.part.aspect.property.AspectProperties;
26	import org.cyclops.integrateddynamics.part.aspect.Aspects;
27
28	import javax.annotation.Nullable;
29	import java.util.IdentityHashMap;
30	import java.util.Map;
31	import java.util.Optional;
32
33	/**
34	* A default implementation of the {@link IPartState}.
35	* @author rubensworks
36	*/
37	public abstract class PartStateBase<P extends IPartType> implements IPartState<P>, IDirtyMarkListener {	×
38
39	private boolean dirty = false;	×
40	private boolean update = false;	×
41	private boolean forceBlockUpdateRender = false;	×
42
43	private int updateInterval = getDefaultUpdateInterval();	×
44	private int priority = 0;	×
45	private int channel = 0;	×
46	private int maxOffset;
47	private Vec3i targetOffset = new Vec3i(0, 0, 0);	×
48	private Direction targetSide = null;	×
49	private int id = -1;	×
50	private Map<IAspect, IAspectProperties> aspectProperties = new IdentityHashMap<>();	×
51	private boolean enabled = true;	×
52	private final Map<String, NonNullList<ItemStack>> inventoriesNamed = Maps.newHashMap();	×
53	private final PartStateOffsetHandler<P> offsetHandler = new PartStateOffsetHandler<>();	×
54
55	private IdentityHashMap<PartCapability<?>, Optional<Object>> volatileCapabilities = new IdentityHashMap<>();	×
56
57	@Override
58	public void serialize(ValueOutput valueOutput) {
59	valueOutput.putInt("updateInterval", this.updateInterval);	×
60	valueOutput.putInt("priority", this.priority);	×
61	valueOutput.putInt("channel", this.channel);	×
62	if (this.targetSide != null) {	×
63	valueOutput.putInt("targetSide", this.targetSide.ordinal());	×
64	}
65	valueOutput.putInt("id", this.id);	×
66	writeAspectProperties(valueOutput.child("aspectProperties"));	×
67	valueOutput.putBoolean("enabled", this.enabled);	×
68	valueOutput.putInt("maxOffset", this.maxOffset);	×
69	valueOutput.putInt("offsetX", this.targetOffset.getX());	×
70	valueOutput.putInt("offsetY", this.targetOffset.getY());	×
71	valueOutput.putInt("offsetZ", this.targetOffset.getZ());	×
72
73	// Write inventoriesNamed
74	ValueOutput.ValueOutputList namedInventoriesList = valueOutput.childrenList("inventoriesNamed");	×
75	for (Map.Entry<String, NonNullList<ItemStack>> entry : this.inventoriesNamed.entrySet()) {	×
76	ValueOutput listEntry = namedInventoriesList.addChild();	×
77	listEntry.putString("tabName", entry.getKey());	×
78	listEntry.putInt("itemCount", entry.getValue().size());	×
79	ContainerHelper.saveAllItems(listEntry, entry.getValue());	×
80	}	×
81
82	ValueOutput.ValueOutputList errorsTag = valueOutput.childrenList("offsetVariablesSlotMessages");	×
83	for (Int2ObjectMap.Entry<MutableComponent> entry : this.offsetHandler.offsetVariablesSlotMessages.int2ObjectEntrySet()) {	×
84	ValueOutput child = errorsTag.addChild();	×
85	String slot = String.valueOf(entry.getIntKey());	×
86	child.putString("slot", slot);	×
87	NBTClassType.writeNbt(MutableComponent.class, slot, entry.getValue(), child);	×
88	}	×
89	}	×
90
91	@Override
92	public void deserialize(ValueInput valueInput) {
93	this.updateInterval = valueInput.getInt("updateInterval").orElseThrow();	×
94	this.priority = valueInput.getInt("priority").orElseThrow();	×
95	this.channel = valueInput.getInt("channel").orElseThrow();	×
96	this.targetSide = valueInput.getInt("targetSide")	×
97	.map(s -> Direction.values()[s])	×
98	.orElse(null);	×
99	this.id = valueInput.getInt("id").orElseThrow();	×
100	this.aspectProperties.clear();	×
101	readAspectProperties(valueInput.child("aspectProperties").orElseThrow());	×
102	this.enabled = valueInput.getBooleanOr("enabled", false);	×
103	this.maxOffset = valueInput.getInt("maxOffset").orElseThrow();	×
104	this.targetOffset = new Vec3i(	×
105	valueInput.getInt("offsetX").orElseThrow(),	×
106	valueInput.getInt("offsetY").orElseThrow(),	×
107	valueInput.getInt("offsetZ").orElseThrow()	×
108	);
109
110	// Read inventoriesNamed
111	for (ValueInput listEntry : valueInput.childrenList("inventoriesNamed").orElseThrow()) {	×
112	NonNullList<ItemStack> list = NonNullList.withSize(listEntry.getInt("itemCount").orElseThrow(), ItemStack.EMPTY);	×
113	String tabName = listEntry.getString("tabName").orElseThrow();	×
114	ContainerHelper.loadAllItems(listEntry, list);	×
115	this.inventoriesNamed.put(tabName, list);	×
116	}	×
117
118	this.offsetHandler.offsetVariablesSlotMessages.clear();	×
119	ValueInput.ValueInputList errorsTag = valueInput.childrenList("offsetVariablesSlotMessages").orElseThrow();	×
120	for (ValueInput child : errorsTag) {	×
121	String slot = child.getString("slot").orElseThrow();	×
122	MutableComponent unlocalizedString = NBTClassType.readNbt(MutableComponent.class, slot, child);	×
123	this.offsetHandler.offsetVariablesSlotMessages.put(Integer.parseInt(slot), unlocalizedString);	×
124	}	×
125	}	×
126
127	protected void writeAspectProperties(ValueOutput valueOutput) {
128	ValueOutput.ValueOutputList list = valueOutput.childrenList("map");	×
129	for(Map.Entry<IAspect, IAspectProperties> entry : aspectProperties.entrySet()) {	×
130	ValueOutput entryTag = list.addChild();	×
131	entryTag.putString("key", entry.getKey().getUniqueName().toString());	×
132	if(entry.getValue() != null) {	×
133	entry.getValue().serialize(entryTag.child("value"));	×
134	}
135	}	×
136	}	×
137
138	public void readAspectProperties(ValueInput valueInput) {
139	for (ValueInput entryTag : valueInput.childrenList("map").orElseThrow()) {	×
140	IAspect key = Aspects.REGISTRY.getAspect(ResourceLocation.parse(entryTag.getString("key").orElseThrow()));	×
141	IAspectProperties value = entryTag.child("value")	×
142	.map(v -> {	×
143	AspectProperties ap = new AspectProperties();	×
144	ap.deserialize(v);	×
145	return ap;	×
146	})
147	.orElse(null);	×
148	if (key != null && value != null) {	×
149	this.aspectProperties.put(key, value);	×
150	}
151	}	×
152	}	×
153
154	@Override
155	public void generateId() {
156	this.id = IntegratedDynamics.globalCounters.get().getNext(IPartState.GLOBALCOUNTER_KEY);	×
157	}	×
158
159	@Override
160	public int getId() {
161	return this.id;	×
162	}
163
164	@Override
165	public void setUpdateInterval(int updateInterval) {
166	this.updateInterval = updateInterval;	×
167	}	×
168
169	@Override
170	public int getUpdateInterval() {
171	return updateInterval;	×
172	}
173
174	@Override
175	public void setPriority(int priority) {
176	this.priority = priority;	×
177	}	×
178
179	@Override
180	public int getPriority() {
181	return priority;	×
182	}
183
184	@Override
185	public void setChannel(int channel) {
186	this.channel = channel;	×
187	}	×
188
189	@Override
190	public int getChannel() {
191	return channel;	×
192	}
193
194	@Override
195	public Vec3i getTargetOffset() {
196	return targetOffset;	×
197	}
198
199	@Override
200	public void setTargetOffset(Vec3i targetOffset) {
201	this.targetOffset = targetOffset;	×
202	this.markDirty();	×
203	}	×
204
205	@Override
206	public void setTargetSideOverride(Direction targetSide) {
207	this.targetSide = targetSide;	×
208	}	×
209
210	@Nullable
211	@Override
212	public Direction getTargetSideOverride() {
213	return targetSide;	×
214	}
215
216	@Override
217	public void markDirty() {
218	this.dirty = true;	×
219	}	×
220
221	@Override
222	public boolean isDirtyAndReset() {
223	boolean wasDirty = this.dirty;	×
224	this.dirty = false;	×
225	return wasDirty;	×
226	}
227
228	@Override
229	public boolean isUpdateAndReset() {
230	boolean wasUpdate = this.update;	×
231	this.update = false;	×
232	return wasUpdate;	×
233	}
234
235	@Override
236	public void forceBlockRenderUpdate() {
237	this.forceBlockUpdateRender = true;	×
238	}	×
239
240	@Override
241	public boolean isForceBlockRenderUpdateAndReset() {
242	boolean wasForceBlockUpdateRender = this.forceBlockUpdateRender;	×
243	this.forceBlockUpdateRender = false;	×
244	return wasForceBlockUpdateRender;	×
245	}
246
247	@Override
248	public void onDirty() {
249	this.dirty = true;	×
250	this.forceBlockRenderUpdate();	×
251	}	×
252
253	/**
254	* Enables a flag that tells the part container to send an NBT update to the client(s).
255	*/
256	public void sendUpdate() {
257	this.update = true;	×
258	}	×
259
260	@Override
261	public IAspectProperties getAspectProperties(IAspect aspect) {
262	return aspectProperties.get(aspect);	×
263	}
264
265	@Override
266	public void setAspectProperties(IAspect aspect, IAspectProperties properties) {
267	aspectProperties.put(aspect, properties);	×
268	sendUpdate();	×
269	}	×
270
271	@Override
272	public void setEnabled(boolean enabled) {
273	boolean wasEnabled = this.enabled;	×
274	this.enabled = enabled;	×
275	if (this.enabled != wasEnabled) {	×
276	sendUpdate();	×
277	}
278	}	×
279
280	@Override
281	public boolean isEnabled() {
282	return enabled;	×
283	}
284
285	public NonNullList<ItemStack> getInventoryNamed(String name) {
286	return this.inventoriesNamed.get(name);	×
287	}
288
289	public void setInventoryNamed(String name, NonNullList<ItemStack> inventory) {
290	this.inventoriesNamed.put(name, inventory);	×
291	onDirty();	×
292	}	×
293
294	@Override
295	public Map<String, NonNullList<ItemStack>> getInventoriesNamed() {
296	return this.inventoriesNamed;	×
297	}
298
299	@Override
300	public void clearInventoriesNamed() {
301	this.inventoriesNamed.clear();	×
302	}	×
303
304	/**
305	* Gathers the capabilities of this part state.
306	* Don't call this unless you know what you're doing!
307	*/
308	public void gatherCapabilities(P partType) {
309	AttachCapabilitiesEventPart event = new AttachCapabilitiesEventPart(partType, this);	×
310	NeoForge.EVENT_BUS.post(event);	×
311	}	×
312
313	@Override
314	public <T> Optional<T> getCapability(P partType, PartCapability<T> capability, INetwork network, IPartNetwork partNetwork, PartTarget target) {
315	Optional<Object> o = volatileCapabilities.get(capability);	×
316	if(o != null && o.isPresent()) {	×
317	return (Optional<T>) o;	×
318	}
319	return Optional.ofNullable(capability.getCapability(partType, target));	×
320	}
321
322	@Override
323	public <T> void addVolatileCapability(PartCapability<T> capability, Optional<T> value) {
324	volatileCapabilities.put(capability, (Optional<Object>) value);	×
325	}	×
326
327	@Override
328	public void removeVolatileCapability(PartCapability<?> capability) {
329	volatileCapabilities.remove(capability);	×
330	}	×
331
332	protected int getDefaultUpdateInterval() {
333	return GeneralConfig.defaultPartUpdateFreq;	×
334	}
335
336	@Override
337	public void initializeOffsets(PartTarget target) {
338	this.offsetHandler.initializeVariableEvaluators(this.offsetHandler.getOffsetVariablesInventory(this), target);	×
339	}	×
340
341	@Override
342	public void updateOffsetVariables(P partType, INetwork network, IPartNetwork partNetwork, PartTarget target) {
343	this.offsetHandler.updateOffsetVariables(partType, this, network, partNetwork, target);	×
344	}	×
345
346	@Nullable
347	@Override
348	public MutableComponent getOffsetVariableError(int slot) {
349	return this.offsetHandler.getOffsetVariableError(slot);	×
350	}
351
352	@Override
353	public boolean requiresOffsetUpdates() {
354	return this.offsetHandler.offsetVariableEvaluators.stream().anyMatch(InventoryVariableEvaluator::hasVariable);	×
355	}
356
357	@Override
358	public void markOffsetVariablesChanged() {
359	this.offsetHandler.markOffsetVariablesChanged();	×
360	}	×
361
362	@Override
363	public int getMaxOffset() {
364	return maxOffset;	×
365	}
366
367	@Override
368	public void setMaxOffset(int maxOffset) {
369	this.maxOffset = maxOffset;	×
370	markDirty();	×
371	}	×
372	}

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