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/helper/NetworkHelpers.java

package org.cyclops.integrateddynamics.core.helper;

import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.util.RandomSource;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.LevelReader;
import net.minecraft.world.level.ScheduledTickAccess;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.redstone.Orientation;
import net.neoforged.neoforge.common.extensions.ILevelExtension;
import org.cyclops.commoncapabilities.api.ingredient.IngredientComponent;
import org.cyclops.cyclopscore.helper.IModHelpersNeoForge;
import org.cyclops.integrateddynamics.Capabilities;
import org.cyclops.integrateddynamics.GeneralConfig;
import org.cyclops.integrateddynamics.IntegratedDynamics;
import org.cyclops.integrateddynamics.api.block.cable.ICableFakeable;
import org.cyclops.integrateddynamics.api.network.*;
import org.cyclops.integrateddynamics.api.part.PartPos;
import org.cyclops.integrateddynamics.api.path.IPathElement;
import org.cyclops.integrateddynamics.capability.path.SidedPathElement;
import org.cyclops.integrateddynamics.core.TickHandler;
import org.cyclops.integrateddynamics.core.network.Network;
import org.cyclops.integrateddynamics.core.persist.world.NetworkWorldStorage;

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

/**
 * Network helper methods.
 * @author rubensworks
 */
public class NetworkHelpers {

    /**
     * Get the network carrier capability at the given position.
     * If possible, prefer using the variant with block state.
     * @param world The world.
     * @param pos The position.
     * @param side The side.
     * @return The optional network carrier capability.
     */
    @Deprecated
    public static Optional<INetworkCarrier> getNetworkCarrier(ILevelExtension world, BlockPos pos, @Nullable Direction side) {
        return IModHelpersNeoForge.get().getCapabilityHelpers().getCapability(world, pos, side, Capabilities.NetworkCarrier.BLOCK);
    }

    /**
     * Get the network carrier capability at the given position.
     * @param world The world.
     * @param pos The position.
     * @param side The side.
     * @param blockState The block state.
     * @return The optional network carrier capability.
     */
    public static Optional<INetworkCarrier> getNetworkCarrier(ILevelExtension world, BlockPos pos, @Nullable Direction side, BlockState blockState) {
        return Optional.ofNullable(world.getCapability(Capabilities.NetworkCarrier.BLOCK, pos, blockState, null, side));
    }

    /**
     * Get the network element provider capability at the given position.
     * If possible, prefer using the variant with block state.
     * @param world The world.
     * @param pos The position.
     * @param side The side.
     * @return The optional network element provider capability.
     */
    @Deprecated
    public static Optional<INetworkElementProvider> getNetworkElementProvider(ILevelExtension world, BlockPos pos, @Nullable Direction side) {
        return IModHelpersNeoForge.get().getCapabilityHelpers().getCapability(world, pos, side, Capabilities.NetworkElementProvider.BLOCK);
    }

    /**
     * Get the network element provider capability at the given position.
     * @param world The world.
     * @param pos The position.
     * @param side The side.
     * @param blockState The block state.
     * @return The optional network element provider capability.
     */
    public static Optional<INetworkElementProvider> getNetworkElementProvider(ILevelExtension world, BlockPos pos, @Nullable Direction side, BlockState blockState) {
        return Optional.ofNullable(world.getCapability(Capabilities.NetworkElementProvider.BLOCK, pos, blockState, null, side));
    }

    /**
     * Get the network at the given position.
     * @param world The world.
     * @param pos The position.
     * @param side The side.
     * @return The optional network.
     */
    public static Optional<INetwork> getNetwork(ILevelExtension world, BlockPos pos, @Nullable Direction side) {
        Optional<Optional<INetwork>> networkCarried = getNetworkCarrier(world, pos, side)
                .map(carrier -> {
                    INetwork network = carrier.getNetwork();
                    return network != null ? Optional.of(network) : Optional.empty();
                });
        return networkCarried.orElse(Optional.empty());
    }

    /**
     * Get the network at the given position.
     * @param pos The position.
     * @return The optional network.
     */
    public static Optional<INetwork> getNetwork(PartPos pos) {
        return getNetwork(pos.getPos().getLevel(true), pos.getPos().getBlockPos(), pos.getSide());
    }

    /**
     * Get the network at the given position.
     * If it is not present, then an illegal state exception will be thrown.
     *
     * This should only be called if you know for certain that there will be a network present.
     *
     * @param world The world.
     * @param pos The position.
     * @param side The side.
     * @return The network.
     */
    public static INetwork getNetworkChecked(ILevelExtension world, BlockPos pos, @Nullable Direction side) {
        return getNetwork(world, pos, side)
                .orElseThrow(() -> new IllegalStateException("Could not find a network container at " + pos.toString()));
    }

    /**
     * Get the network at the given position.
     * If it is not present, then an illegal state exception will be thrown.
     *
     * This should only be called if you know for certain that there will be a network present.
     *
     * @param pos The position.
     * @return The network.
     */
    public static INetwork getNetworkChecked(PartPos pos) {
        return getNetwork(pos)
                .orElseThrow(() -> new IllegalStateException("Could not find a network container at " + pos.toString()));
    }

    /**
     * Get the part network capability of a network.
     * @param optionalNetwork The optional network.
     * @return The optional part network.
     */
    public static Optional<IPartNetwork> getPartNetwork(Optional<INetwork> optionalNetwork) {
        return optionalNetwork
                .map(network -> network.getCapability(Capabilities.PartNetwork.NETWORK))
                .orElse(Optional.empty());
    }

    /**
     * Get the part network capability of a network.
     * @param network The network.
     * @return The optional part network.
     */
    public static Optional<IPartNetwork> getPartNetwork(@Nullable INetwork network) {
        if (network == null) {
            return Optional.empty();
        }
        return network.getCapability(Capabilities.PartNetwork.NETWORK);
    }

    /**
     * Get the part network capability of a network.
     * If it is not present, then an illegal state exception will be thrown.
     *
     * This should only be called if you know for certain that there will be a part network present.
     *
     * @param network The network.
     * @return The part network.
     */
    public static IPartNetwork getPartNetworkChecked(INetwork network) {
        return network.getCapability(Capabilities.PartNetwork.NETWORK)
                .orElseThrow(() -> new IllegalStateException("Could not find a network's part network"));
    }

    /**
     * Get the part network capability of a network.
     * @param optionalNetwork The optional network.
     * @return The optional energy network.
     */
    public static Optional<IEnergyNetwork> getEnergyNetwork(Optional<INetwork> optionalNetwork) {
        return optionalNetwork
                .map(network -> network.getCapability(Capabilities.EnergyNetwork.NETWORK))
                .orElse(Optional.empty());
    }

    /**
     * Get the part network capability of a network.
     * @param network The network.
     * @return The optional energy network.
     */
    public static Optional<IEnergyNetwork> getEnergyNetwork(@Nullable INetwork network) {
        if (network == null) {
            return Optional.empty();
        }
        return network.getCapability(Capabilities.EnergyNetwork.NETWORK);
    }

    /**
     * Get the part network capability of a network.
     * @param network The network.
     * @return The energy network.
     */
    public static IEnergyNetwork getEnergyNetworkChecked(INetwork network) {
        return network.getCapability(Capabilities.EnergyNetwork.NETWORK)
                .orElseThrow(() -> new IllegalStateException("Could not find a network's energy network"));
    }

    /**
     * Get the ingredient network within a network.
     * @param optionalNetwork The optional network.
     * @param ingredientComponent The ingredient component type.
     * @param <T> The instance type.
     * @param <M> The matching condition parameter.
     * @return The optional ingredient network.
     */
    public static <T, M> Optional<IPositionedAddonsNetworkIngredients<T, M>> getIngredientNetwork(Optional<INetwork> optionalNetwork,
                                                                                                      IngredientComponent<T, M> ingredientComponent) {
        return optionalNetwork
                .map(network -> ingredientComponent.getCapability(Capabilities.PositionedAddonsNetworkIngredientsHandler.INGREDIENT)
                        .map(handler -> handler.getStorage(network))
                        .orElse(Optional.empty()))
                .orElse(Optional.empty());
    }

    /**
     * Form a new network starting from the given position.
     * This position should have a {@link IPathElement} capability,
     * otherwise this method will fail silently.
     * This will correctly transfer all passed network elements to this new network.
     * @param world The world.
     * @param pos The starting position.
     * @param side The side.
     * @return The optionally created part network.
     * Can be absent if the starting position did not have a {@link IPathElement} capability.
     */
    public static Optional<INetwork> initNetwork(ILevelExtension world, BlockPos pos, @Nullable Direction side) {
        return IModHelpersNeoForge.get().getCapabilityHelpers().getCapability(world, pos, side, Capabilities.PathElement.BLOCK)
                .map(pathElement -> {
                    Network network = Network.initiateNetworkSetup(SidedPathElement.of(pathElement, side));
                    network.initialize();
                    return Optional.<INetwork>of(network);
                })
                .orElse(Optional.empty());
    }

    /**
     * This MUST be called by blocks having the {@link INetworkElementProvider} capability in
     * when a neighbouring block is updated, more specifically when
     * {@link Block#neighborChanged(BlockState, Level, BlockPos, Block, Orientation, boolean)},
     * {@link Block#onNeighborChange(BlockState, LevelReader, BlockPos, BlockPos)}
     * or {@link Block#updateShape(BlockState, LevelReader, ScheduledTickAccess, BlockPos, Direction, BlockPos, BlockState, RandomSource)} is called.
     *
     * @param world The world in which the neighbour was updated.
     * @param pos   The position of the center block.
     * @param side  The side at the center block.
     */
    public static void onElementProviderBlockNeighborChange(Level world, BlockPos pos,
                                                            @Nullable Direction side) {
        if (!world.isClientSide()) {
            getNetwork(world, pos, side).ifPresent(network -> {
                getNetworkElementProvider(world, pos, side).ifPresent(networkElementProvider -> {
                    for (INetworkElement networkElement : networkElementProvider.createNetworkElements(world, pos)) {
                        networkElement.onNeighborBlockChange(network, world, side);
                    }
                });
            });
        }
    }

    /**
     * @return If networks should work and evaluations should be done.
     */
    public static boolean shouldWork() {
        return !GeneralConfig.safeMode;
    }

    /**
     * Invalidate all network elements at the given position.
     * Warning: this assumes unsided network carrier capabilities, for example full-block network elements.
     * @param world The world.
     * @param pos The position.
     * @param network The network.
     * @param networkElementProvider The network element provider.
     */
    public static void invalidateNetworkElements(Level world, BlockPos pos, INetwork network, INetworkElementProvider networkElementProvider) {
        for (INetworkElement networkElement : networkElementProvider.createNetworkElements(world, pos)) {
            networkElement.invalidate(network);
        }
    }

    /**
     * Revalidate all network elements at the given position.
     * Warning: this assumes unsided network carrier capabilities, for example full-block network elements.
     * @param world The world.
     * @param pos The position.
     * @return If the network was revalidated in this tick.
     */
    public static boolean revalidateNetworkElements(Level world, BlockPos pos) {
        INetworkCarrier networkCarrier = IModHelpersNeoForge.get().getCapabilityHelpers().getCapability(world, pos, Capabilities.NetworkCarrier.BLOCK).orElse(null);
        IPathElement pathElement = IModHelpersNeoForge.get().getCapabilityHelpers().getCapability(world, pos, Capabilities.PathElement.BLOCK).orElse(null);
        if (TickHandler.getInstance().ticked
                && networkCarrier != null && pathElement != null && networkCarrier.getNetwork() == null
                && IModHelpersNeoForge.get().getCapabilityHelpers().getCapability(world, pos, Capabilities.CableFakeable.BLOCK).map(ICableFakeable::isRealCable).orElse(true)) {
            return IModHelpersNeoForge.get().getCapabilityHelpers().getCapability(world, pos, Capabilities.NetworkElementProvider.BLOCK).map(networkElementProvider -> {
                // Attempt to revalidate the network elements in this provider
                boolean foundNetwork = false;
                for (INetwork network : NetworkWorldStorage.Access.getInstance(IntegratedDynamics._instance).get().getNetworks()) {
                    if (network.containsSidedPathElement(SidedPathElement.of(pathElement, null))) {
                        // Revalidate all network elements
                        for (INetworkElement networkElement : networkElementProvider.createNetworkElements(world, pos)) {
                            networkElement.revalidate(network);
                        }
                        foundNetwork = true;
                        break; // No need to check the other networks anymore
                    }
                }

                // If no existing network was found, create a new network
                if (!foundNetwork && GeneralConfig.recreateCorruptedNetworks) {
                    IntegratedDynamics.clog(org.apache.logging.log4j.Level.WARN, String.format("Detected network position at " +
                            "position %s in world %s with corrupted network, recreating network...", pos, world.dimension().location()));
                    NetworkHelpers.initNetwork(world, pos, null);
                    return true;
                }

                return foundNetwork;
            }).orElse(false);
        }
        return false;
    }

}

1	package org.cyclops.integrateddynamics.core.helper;
2
3	import net.minecraft.core.BlockPos;
4	import net.minecraft.core.Direction;
5	import net.minecraft.util.RandomSource;
6	import net.minecraft.world.level.Level;
7	import net.minecraft.world.level.LevelReader;
8	import net.minecraft.world.level.ScheduledTickAccess;
9	import net.minecraft.world.level.block.Block;
10	import net.minecraft.world.level.block.state.BlockState;
11	import net.minecraft.world.level.redstone.Orientation;
12	import net.neoforged.neoforge.common.extensions.ILevelExtension;
13	import org.cyclops.commoncapabilities.api.ingredient.IngredientComponent;
14	import org.cyclops.cyclopscore.helper.IModHelpersNeoForge;
15	import org.cyclops.integrateddynamics.Capabilities;
16	import org.cyclops.integrateddynamics.GeneralConfig;
17	import org.cyclops.integrateddynamics.IntegratedDynamics;
18	import org.cyclops.integrateddynamics.api.block.cable.ICableFakeable;
19	import org.cyclops.integrateddynamics.api.network.*;
20	import org.cyclops.integrateddynamics.api.part.PartPos;
21	import org.cyclops.integrateddynamics.api.path.IPathElement;
22	import org.cyclops.integrateddynamics.capability.path.SidedPathElement;
23	import org.cyclops.integrateddynamics.core.TickHandler;
24	import org.cyclops.integrateddynamics.core.network.Network;
25	import org.cyclops.integrateddynamics.core.persist.world.NetworkWorldStorage;
26
27	import javax.annotation.Nullable;
28	import java.util.Optional;
29
30	/**
31	* Network helper methods.
32	* @author rubensworks
33	*/
34	public class NetworkHelpers {	×
35
36	/**
37	* Get the network carrier capability at the given position.
38	* If possible, prefer using the variant with block state.
39	* @param world The world.
40	* @param pos The position.
41	* @param side The side.
42	* @return The optional network carrier capability.
43	*/
44	@Deprecated
45	public static Optional<INetworkCarrier> getNetworkCarrier(ILevelExtension world, BlockPos pos, @Nullable Direction side) {
46	return IModHelpersNeoForge.get().getCapabilityHelpers().getCapability(world, pos, side, Capabilities.NetworkCarrier.BLOCK);	×
47	}
48
49	/**
50	* Get the network carrier capability at the given position.
51	* @param world The world.
52	* @param pos The position.
53	* @param side The side.
54	* @param blockState The block state.
55	* @return The optional network carrier capability.
56	*/
57	public static Optional<INetworkCarrier> getNetworkCarrier(ILevelExtension world, BlockPos pos, @Nullable Direction side, BlockState blockState) {
58	return Optional.ofNullable(world.getCapability(Capabilities.NetworkCarrier.BLOCK, pos, blockState, null, side));	×
59	}
60
61	/**
62	* Get the network element provider capability at the given position.
63	* If possible, prefer using the variant with block state.
64	* @param world The world.
65	* @param pos The position.
66	* @param side The side.
67	* @return The optional network element provider capability.
68	*/
69	@Deprecated
70	public static Optional<INetworkElementProvider> getNetworkElementProvider(ILevelExtension world, BlockPos pos, @Nullable Direction side) {
71	return IModHelpersNeoForge.get().getCapabilityHelpers().getCapability(world, pos, side, Capabilities.NetworkElementProvider.BLOCK);	×
72	}
73
74	/**
75	* Get the network element provider capability at the given position.
76	* @param world The world.
77	* @param pos The position.
78	* @param side The side.
79	* @param blockState The block state.
80	* @return The optional network element provider capability.
81	*/
82	public static Optional<INetworkElementProvider> getNetworkElementProvider(ILevelExtension world, BlockPos pos, @Nullable Direction side, BlockState blockState) {
83	return Optional.ofNullable(world.getCapability(Capabilities.NetworkElementProvider.BLOCK, pos, blockState, null, side));	×
84	}
85
86	/**
87	* Get the network at the given position.
88	* @param world The world.
89	* @param pos The position.
90	* @param side The side.
91	* @return The optional network.
92	*/
93	public static Optional<INetwork> getNetwork(ILevelExtension world, BlockPos pos, @Nullable Direction side) {
94	Optional<Optional<INetwork>> networkCarried = getNetworkCarrier(world, pos, side)	×
95	.map(carrier -> {	×
96	INetwork network = carrier.getNetwork();	×
97	return network != null ? Optional.of(network) : Optional.empty();	×
98	});
99	return networkCarried.orElse(Optional.empty());	×
100	}
101
102	/**
103	* Get the network at the given position.
104	* @param pos The position.
105	* @return The optional network.
106	*/
107	public static Optional<INetwork> getNetwork(PartPos pos) {
108	return getNetwork(pos.getPos().getLevel(true), pos.getPos().getBlockPos(), pos.getSide());	×
109	}
110
111	/**
112	* Get the network at the given position.
113	* If it is not present, then an illegal state exception will be thrown.
114	*
115	* This should only be called if you know for certain that there will be a network present.
116	*
117	* @param world The world.
118	* @param pos The position.
119	* @param side The side.
120	* @return The network.
121	*/
122	public static INetwork getNetworkChecked(ILevelExtension world, BlockPos pos, @Nullable Direction side) {
123	return getNetwork(world, pos, side)	×
124	.orElseThrow(() -> new IllegalStateException("Could not find a network container at " + pos.toString()));	×
125	}
126
127	/**
128	* Get the network at the given position.
129	* If it is not present, then an illegal state exception will be thrown.
130	*
131	* This should only be called if you know for certain that there will be a network present.
132	*
133	* @param pos The position.
134	* @return The network.
135	*/
136	public static INetwork getNetworkChecked(PartPos pos) {
137	return getNetwork(pos)	×
138	.orElseThrow(() -> new IllegalStateException("Could not find a network container at " + pos.toString()));	×
139	}
140
141	/**
142	* Get the part network capability of a network.
143	* @param optionalNetwork The optional network.
144	* @return The optional part network.
145	*/
146	public static Optional<IPartNetwork> getPartNetwork(Optional<INetwork> optionalNetwork) {
147	return optionalNetwork	×
148	.map(network -> network.getCapability(Capabilities.PartNetwork.NETWORK))	×
149	.orElse(Optional.empty());	×
150	}
151
152	/**
153	* Get the part network capability of a network.
154	* @param network The network.
155	* @return The optional part network.
156	*/
157	public static Optional<IPartNetwork> getPartNetwork(@Nullable INetwork network) {
158	if (network == null) {	×
159	return Optional.empty();	×
160	}
161	return network.getCapability(Capabilities.PartNetwork.NETWORK);	×
162	}
163
164	/**
165	* Get the part network capability of a network.
166	* If it is not present, then an illegal state exception will be thrown.
167	*
168	* This should only be called if you know for certain that there will be a part network present.
169	*
170	* @param network The network.
171	* @return The part network.
172	*/
173	public static IPartNetwork getPartNetworkChecked(INetwork network) {
174	return network.getCapability(Capabilities.PartNetwork.NETWORK)	×
175	.orElseThrow(() -> new IllegalStateException("Could not find a network's part network"));	×
176	}
177
178	/**
179	* Get the part network capability of a network.
180	* @param optionalNetwork The optional network.
181	* @return The optional energy network.
182	*/
183	public static Optional<IEnergyNetwork> getEnergyNetwork(Optional<INetwork> optionalNetwork) {
184	return optionalNetwork	×
185	.map(network -> network.getCapability(Capabilities.EnergyNetwork.NETWORK))	×
186	.orElse(Optional.empty());	×
187	}
188
189	/**
190	* Get the part network capability of a network.
191	* @param network The network.
192	* @return The optional energy network.
193	*/
194	public static Optional<IEnergyNetwork> getEnergyNetwork(@Nullable INetwork network) {
195	if (network == null) {	×
196	return Optional.empty();	×
197	}
198	return network.getCapability(Capabilities.EnergyNetwork.NETWORK);	×
199	}
200
201	/**
202	* Get the part network capability of a network.
203	* @param network The network.
204	* @return The energy network.
205	*/
206	public static IEnergyNetwork getEnergyNetworkChecked(INetwork network) {
207	return network.getCapability(Capabilities.EnergyNetwork.NETWORK)	×
208	.orElseThrow(() -> new IllegalStateException("Could not find a network's energy network"));	×
209	}
210
211	/**
212	* Get the ingredient network within a network.
213	* @param optionalNetwork The optional network.
214	* @param ingredientComponent The ingredient component type.
215	* @param <T> The instance type.
216	* @param <M> The matching condition parameter.
217	* @return The optional ingredient network.
218	*/
219	public static <T, M> Optional<IPositionedAddonsNetworkIngredients<T, M>> getIngredientNetwork(Optional<INetwork> optionalNetwork,
220	IngredientComponent<T, M> ingredientComponent) {
221	return optionalNetwork	×
222	.map(network -> ingredientComponent.getCapability(Capabilities.PositionedAddonsNetworkIngredientsHandler.INGREDIENT)	×
223	.map(handler -> handler.getStorage(network))	×
224	.orElse(Optional.empty()))	×
225	.orElse(Optional.empty());	×
226	}
227
228	/**
229	* Form a new network starting from the given position.
230	* This position should have a {@link IPathElement} capability,
231	* otherwise this method will fail silently.
232	* This will correctly transfer all passed network elements to this new network.
233	* @param world The world.
234	* @param pos The starting position.
235	* @param side The side.
236	* @return The optionally created part network.
237	* Can be absent if the starting position did not have a {@link IPathElement} capability.
238	*/
239	public static Optional<INetwork> initNetwork(ILevelExtension world, BlockPos pos, @Nullable Direction side) {
240	return IModHelpersNeoForge.get().getCapabilityHelpers().getCapability(world, pos, side, Capabilities.PathElement.BLOCK)	×
241	.map(pathElement -> {	×
242	Network network = Network.initiateNetworkSetup(SidedPathElement.of(pathElement, side));	×
243	network.initialize();	×
244	return Optional.<INetwork>of(network);	×
245	})
246	.orElse(Optional.empty());	×
247	}
248
249	/**
250	* This MUST be called by blocks having the {@link INetworkElementProvider} capability in
251	* when a neighbouring block is updated, more specifically when
252	* {@link Block#neighborChanged(BlockState, Level, BlockPos, Block, Orientation, boolean)},
253	* {@link Block#onNeighborChange(BlockState, LevelReader, BlockPos, BlockPos)}
254	* or {@link Block#updateShape(BlockState, LevelReader, ScheduledTickAccess, BlockPos, Direction, BlockPos, BlockState, RandomSource)} is called.
255	*
256	* @param world The world in which the neighbour was updated.
257	* @param pos The position of the center block.
258	* @param side The side at the center block.
259	*/
260	public static void onElementProviderBlockNeighborChange(Level world, BlockPos pos,
261	@Nullable Direction side) {
262	if (!world.isClientSide()) {	×
263	getNetwork(world, pos, side).ifPresent(network -> {	×
264	getNetworkElementProvider(world, pos, side).ifPresent(networkElementProvider -> {	×
265	for (INetworkElement networkElement : networkElementProvider.createNetworkElements(world, pos)) {	×
266	networkElement.onNeighborBlockChange(network, world, side);	×
267	}	×
268	});	×
269	});	×
270	}
271	}	×
272
273	/**
274	* @return If networks should work and evaluations should be done.
275	*/
276	public static boolean shouldWork() {
277	return !GeneralConfig.safeMode;	×
278	}
279
280	/**
281	* Invalidate all network elements at the given position.
282	* Warning: this assumes unsided network carrier capabilities, for example full-block network elements.
283	* @param world The world.
284	* @param pos The position.
285	* @param network The network.
286	* @param networkElementProvider The network element provider.
287	*/
288	public static void invalidateNetworkElements(Level world, BlockPos pos, INetwork network, INetworkElementProvider networkElementProvider) {
289	for (INetworkElement networkElement : networkElementProvider.createNetworkElements(world, pos)) {	×
290	networkElement.invalidate(network);	×
291	}	×
292	}	×
293
294	/**
295	* Revalidate all network elements at the given position.
296	* Warning: this assumes unsided network carrier capabilities, for example full-block network elements.
297	* @param world The world.
298	* @param pos The position.
299	* @return If the network was revalidated in this tick.
300	*/
301	public static boolean revalidateNetworkElements(Level world, BlockPos pos) {
302	INetworkCarrier networkCarrier = IModHelpersNeoForge.get().getCapabilityHelpers().getCapability(world, pos, Capabilities.NetworkCarrier.BLOCK).orElse(null);	×
303	IPathElement pathElement = IModHelpersNeoForge.get().getCapabilityHelpers().getCapability(world, pos, Capabilities.PathElement.BLOCK).orElse(null);	×
304	if (TickHandler.getInstance().ticked	×
305	&& networkCarrier != null && pathElement != null && networkCarrier.getNetwork() == null	×
306	&& IModHelpersNeoForge.get().getCapabilityHelpers().getCapability(world, pos, Capabilities.CableFakeable.BLOCK).map(ICableFakeable::isRealCable).orElse(true)) {	×
307	return IModHelpersNeoForge.get().getCapabilityHelpers().getCapability(world, pos, Capabilities.NetworkElementProvider.BLOCK).map(networkElementProvider -> {	×
308	// Attempt to revalidate the network elements in this provider
309	boolean foundNetwork = false;	×
310	for (INetwork network : NetworkWorldStorage.Access.getInstance(IntegratedDynamics._instance).get().getNetworks()) {	×
311	if (network.containsSidedPathElement(SidedPathElement.of(pathElement, null))) {	×
312	// Revalidate all network elements
313	for (INetworkElement networkElement : networkElementProvider.createNetworkElements(world, pos)) {	×
314	networkElement.revalidate(network);	×
315	}	×
316	foundNetwork = true;	×
317	break; // No need to check the other networks anymore	×
318	}
319	}	×
320
321	// If no existing network was found, create a new network
322	if (!foundNetwork && GeneralConfig.recreateCorruptedNetworks) {	×
323	IntegratedDynamics.clog(org.apache.logging.log4j.Level.WARN, String.format("Detected network position at " +	×
324	"position %s in world %s with corrupted network, recreating network...", pos, world.dimension().location()));	×
325	NetworkHelpers.initNetwork(world, pos, null);	×
326	return true;	×
327	}
328
329	return foundNetwork;	×
330	}).orElse(false);	×
331	}
332	return false;	×
333	}
334
335	}

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