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/network/diagnostics/NetworkDiagnostics.java

package org.cyclops.integrateddynamics.core.network.diagnostics;

import com.google.common.collect.Lists;
import net.minecraft.server.level.ServerPlayer;
import net.neoforged.neoforge.server.ServerLifecycleHooks;
import org.cyclops.integrateddynamics.IntegratedDynamics;
import org.cyclops.integrateddynamics.api.network.*;
import org.cyclops.integrateddynamics.api.part.PartPos;
import org.cyclops.integrateddynamics.core.persist.world.NetworkWorldStorage;
import org.cyclops.integrateddynamics.network.packet.NetworkDiagnosticsNetworkPacket;

import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.UUID;

/**
 * @author rubensworks
 */
public class NetworkDiagnostics {

    private static final NetworkDiagnostics _INSTANCE = new NetworkDiagnostics();

    private final List<UUID> players = Lists.newArrayList();

    private NetworkDiagnostics() {

    }

    public static NetworkDiagnostics getInstance() {
        return _INSTANCE;
    }

    protected ServerPlayer getPlayer(UUID uuid) {
        return ServerLifecycleHooks.getCurrentServer().getPlayerList().getPlayer(uuid);
    }

    public synchronized void registerPlayer(ServerPlayer player) {
        if (!players.contains(player.getUUID())) {
            players.add(player.getUUID());
            for (INetwork network : NetworkWorldStorage.Access.getInstance(IntegratedDynamics._instance).get().getNetworks()) {
                sendNetworkUpdateToPlayer(player, network);
            }

        }
    }

    public synchronized void unRegisterPlayer(ServerPlayer player) {
        players.remove(player.getUUID());
    }

    public void sendNetworkUpdateToPlayer(ServerPlayer player, INetwork network) {
        List<RawPartData> rawParts = Lists.newArrayList();
        for (INetworkElement networkElement : network.getElements()) {
            if (network.isValid(networkElement) && networkElement instanceof IPartNetworkElement) {
                IPartNetworkElement partNetworkElement = (IPartNetworkElement) networkElement;
                PartPos pos = partNetworkElement.getTarget().getCenter();
                long lastSecondDurationNs = network.getLastSecondDuration(networkElement);
                rawParts.add(new RawPartData(pos.getPos().getLevelKey(),
                        pos.getPos().getBlockPos(), pos.getSide(),
                        partNetworkElement.getPart().getTranslationKey(),
                        lastSecondDurationNs));
            } else {
                // If needed, we can send the other part types later on as well
            }
        }

        List<RawObserverData> rawObservers = Lists.newArrayList();
        for (IFullNetworkListener fullNetworkListener : network.getFullNetworkListeners()) {
            if (fullNetworkListener instanceof IPositionedAddonsNetworkIngredients) {
                IPositionedAddonsNetworkIngredients<?, ?> networkIngredients = (IPositionedAddonsNetworkIngredients<?, ?>) fullNetworkListener;
                Map<PartPos, Long> durations = networkIngredients.getLastSecondDurationIndex();
                for (Map.Entry<PartPos, Long> durationEntry : durations.entrySet()) {
                    PartPos pos = durationEntry.getKey();
                    rawObservers.add(new RawObserverData(pos.getPos().getLevelKey(),
                            pos.getPos().getBlockPos(), pos.getSide(),
                            networkIngredients.getComponent().getName().toString(), durationEntry.getValue()));
                }
            }
        }

        RawNetworkData rawNetworkData = new RawNetworkData(network.isKilled(), network.hashCode(), network.getCablesCount(), rawParts, rawObservers);
        IntegratedDynamics._instance.getPacketHandler().sendToPlayer(new NetworkDiagnosticsNetworkPacket(rawNetworkData.toNbt()), player);
    }

    public synchronized void sendNetworkUpdate(INetwork network) {
        for (Iterator<UUID> it = players.iterator(); it.hasNext();) {
            UUID uuid = it.next();
            ServerPlayer player = getPlayer(uuid);
            if (player != null) {
                sendNetworkUpdateToPlayer(player, network);
            } else {
                it.remove();
            }
        }
    }

    public synchronized boolean isBeingDiagnozed() {
        return !players.isEmpty();
    }

}

1	package org.cyclops.integrateddynamics.core.network.diagnostics;
2
3	import com.google.common.collect.Lists;
4	import net.minecraft.server.level.ServerPlayer;
5	import net.neoforged.neoforge.server.ServerLifecycleHooks;
6	import org.cyclops.integrateddynamics.IntegratedDynamics;
7	import org.cyclops.integrateddynamics.api.network.*;
8	import org.cyclops.integrateddynamics.api.part.PartPos;
9	import org.cyclops.integrateddynamics.core.persist.world.NetworkWorldStorage;
10	import org.cyclops.integrateddynamics.network.packet.NetworkDiagnosticsNetworkPacket;
11
12	import java.util.Iterator;
13	import java.util.List;
14	import java.util.Map;
15	import java.util.UUID;
16
17	/**
18	* @author rubensworks
19	*/
20	public class NetworkDiagnostics {
21
22	private static final NetworkDiagnostics _INSTANCE = new NetworkDiagnostics();	×
23
24	private final List<UUID> players = Lists.newArrayList();	×
25
26	private NetworkDiagnostics() {	×
27
28	}	×
29
30	public static NetworkDiagnostics getInstance() {
31	return _INSTANCE;	×
32	}
33
34	protected ServerPlayer getPlayer(UUID uuid) {
35	return ServerLifecycleHooks.getCurrentServer().getPlayerList().getPlayer(uuid);	×
36	}
37
38	public synchronized void registerPlayer(ServerPlayer player) {
39	if (!players.contains(player.getUUID())) {	×
40	players.add(player.getUUID());	×
41	for (INetwork network : NetworkWorldStorage.Access.getInstance(IntegratedDynamics._instance).get().getNetworks()) {	×
42	sendNetworkUpdateToPlayer(player, network);	×
43	}	×
44
45	}
46	}	×
47
48	public synchronized void unRegisterPlayer(ServerPlayer player) {
49	players.remove(player.getUUID());	×
50	}	×
51
52	public void sendNetworkUpdateToPlayer(ServerPlayer player, INetwork network) {
53	List<RawPartData> rawParts = Lists.newArrayList();	×
54	for (INetworkElement networkElement : network.getElements()) {	×
55	if (network.isValid(networkElement) && networkElement instanceof IPartNetworkElement) {	×
56	IPartNetworkElement partNetworkElement = (IPartNetworkElement) networkElement;	×
57	PartPos pos = partNetworkElement.getTarget().getCenter();	×
58	long lastSecondDurationNs = network.getLastSecondDuration(networkElement);	×
59	rawParts.add(new RawPartData(pos.getPos().getLevelKey(),	×
60	pos.getPos().getBlockPos(), pos.getSide(),	×
61	partNetworkElement.getPart().getTranslationKey(),	×
62	lastSecondDurationNs));
63	} else {
64	// If needed, we can send the other part types later on as well
65	}
66	}	×
67
68	List<RawObserverData> rawObservers = Lists.newArrayList();	×
69	for (IFullNetworkListener fullNetworkListener : network.getFullNetworkListeners()) {	×
70	if (fullNetworkListener instanceof IPositionedAddonsNetworkIngredients) {	×
71	IPositionedAddonsNetworkIngredients<?, ?> networkIngredients = (IPositionedAddonsNetworkIngredients<?, ?>) fullNetworkListener;	×
72	Map<PartPos, Long> durations = networkIngredients.getLastSecondDurationIndex();	×
73	for (Map.Entry<PartPos, Long> durationEntry : durations.entrySet()) {	×
74	PartPos pos = durationEntry.getKey();	×
75	rawObservers.add(new RawObserverData(pos.getPos().getLevelKey(),	×
76	pos.getPos().getBlockPos(), pos.getSide(),	×
77	networkIngredients.getComponent().getName().toString(), durationEntry.getValue()));	×
78	}	×
79	}
80	}
81
82	RawNetworkData rawNetworkData = new RawNetworkData(network.isKilled(), network.hashCode(), network.getCablesCount(), rawParts, rawObservers);	×
83	IntegratedDynamics._instance.getPacketHandler().sendToPlayer(new NetworkDiagnosticsNetworkPacket(rawNetworkData.toNbt()), player);	×
84	}	×
85
86	public synchronized void sendNetworkUpdate(INetwork network) {
87	for (Iterator<UUID> it = players.iterator(); it.hasNext();) {	×
88	UUID uuid = it.next();	×
89	ServerPlayer player = getPlayer(uuid);	×
90	if (player != null) {	×
91	sendNetworkUpdateToPlayer(player, network);	×
92	} else {
93	it.remove();	×
94	}
95	}	×
96	}	×
97
98	public synchronized boolean isBeingDiagnozed() {
99	return !players.isEmpty();	×
100	}
101
102	}

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