mirror of
https://github.com/Creators-of-Create/Create.git
synced 2024-06-10 22:58:56 +02:00
273 lines
8.7 KiB
Java
273 lines
8.7 KiB
Java
package com.simibubi.create.content.logistics.trains;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Map.Entry;
|
|
import java.util.Objects;
|
|
import java.util.UUID;
|
|
|
|
import com.simibubi.create.Create;
|
|
import com.simibubi.create.content.logistics.trains.management.edgePoint.EdgeData;
|
|
import com.simibubi.create.content.logistics.trains.management.edgePoint.EdgePointType;
|
|
import com.simibubi.create.content.logistics.trains.management.edgePoint.signal.TrackEdgePoint;
|
|
import com.simibubi.create.foundation.utility.Couple;
|
|
import com.simibubi.create.foundation.utility.Pair;
|
|
import com.simibubi.create.foundation.utility.VecHelper;
|
|
|
|
import net.minecraft.network.FriendlyByteBuf;
|
|
import net.minecraft.world.phys.Vec3;
|
|
|
|
public class TrackGraphSyncPacket extends TrackGraphPacket {
|
|
|
|
Map<Integer, Pair<TrackNodeLocation, Vec3>> addedNodes;
|
|
List<Pair<Pair<Couple<Integer>, TrackMaterial>, BezierConnection>> addedEdges;
|
|
List<Integer> removedNodes;
|
|
List<TrackEdgePoint> addedEdgePoints;
|
|
List<UUID> removedEdgePoints;
|
|
Map<Integer, Pair<Integer, UUID>> splitSubGraphs;
|
|
Map<Couple<Integer>, Pair<Integer, List<UUID>>> updatedEdgeData;
|
|
|
|
boolean fullWipe;
|
|
|
|
static final int NULL_GROUP = 0, PASSIVE_GROUP = 1, GROUP = 2;
|
|
|
|
public TrackGraphSyncPacket(UUID graphId, int netId) {
|
|
this.graphId = graphId;
|
|
this.netId = netId;
|
|
addedNodes = new HashMap<>();
|
|
addedEdges = new ArrayList<>();
|
|
removedNodes = new ArrayList<>();
|
|
addedEdgePoints = new ArrayList<>();
|
|
removedEdgePoints = new ArrayList<>();
|
|
updatedEdgeData = new HashMap<>();
|
|
splitSubGraphs = new HashMap<>();
|
|
packetDeletesGraph = false;
|
|
}
|
|
|
|
public TrackGraphSyncPacket(FriendlyByteBuf buffer) {
|
|
int size;
|
|
|
|
graphId = buffer.readUUID();
|
|
netId = buffer.readInt();
|
|
packetDeletesGraph = buffer.readBoolean();
|
|
fullWipe = buffer.readBoolean();
|
|
|
|
if (packetDeletesGraph)
|
|
return;
|
|
|
|
DimensionPalette dimensions = DimensionPalette.receive(buffer);
|
|
|
|
addedNodes = new HashMap<>();
|
|
addedEdges = new ArrayList<>();
|
|
addedEdgePoints = new ArrayList<>();
|
|
removedEdgePoints = new ArrayList<>();
|
|
removedNodes = new ArrayList<>();
|
|
splitSubGraphs = new HashMap<>();
|
|
updatedEdgeData = new HashMap<>();
|
|
|
|
size = buffer.readVarInt();
|
|
for (int i = 0; i < size; i++)
|
|
removedNodes.add(buffer.readVarInt());
|
|
|
|
size = buffer.readVarInt();
|
|
for (int i = 0; i < size; i++)
|
|
addedNodes.put(buffer.readVarInt(),
|
|
Pair.of(TrackNodeLocation.receive(buffer, dimensions), VecHelper.read(buffer)));
|
|
|
|
size = buffer.readVarInt();
|
|
for (int i = 0; i < size; i++)
|
|
addedEdges.add(
|
|
Pair.of(Pair.of(Couple.create(buffer::readVarInt), TrackMaterial.deserialize(buffer.readUtf())), buffer.readBoolean() ? new BezierConnection(buffer) : null));
|
|
|
|
size = buffer.readVarInt();
|
|
for (int i = 0; i < size; i++)
|
|
addedEdgePoints.add(EdgePointType.read(buffer, dimensions));
|
|
|
|
size = buffer.readVarInt();
|
|
for (int i = 0; i < size; i++)
|
|
removedEdgePoints.add(buffer.readUUID());
|
|
|
|
size = buffer.readVarInt();
|
|
for (int i = 0; i < size; i++) {
|
|
ArrayList<UUID> list = new ArrayList<>();
|
|
Couple<Integer> key = Couple.create(buffer::readInt);
|
|
Pair<Integer, List<UUID>> entry = Pair.of(buffer.readVarInt(), list);
|
|
int size2 = buffer.readVarInt();
|
|
for (int j = 0; j < size2; j++)
|
|
list.add(buffer.readUUID());
|
|
updatedEdgeData.put(key, entry);
|
|
}
|
|
|
|
size = buffer.readVarInt();
|
|
for (int i = 0; i < size; i++)
|
|
splitSubGraphs.put(buffer.readVarInt(), Pair.of(buffer.readInt(), buffer.readUUID()));
|
|
}
|
|
|
|
@Override
|
|
public void write(FriendlyByteBuf buffer) {
|
|
buffer.writeUUID(graphId);
|
|
buffer.writeInt(netId);
|
|
buffer.writeBoolean(packetDeletesGraph);
|
|
buffer.writeBoolean(fullWipe);
|
|
|
|
if (packetDeletesGraph)
|
|
return;
|
|
|
|
// Populate and send palette ahead of time
|
|
DimensionPalette dimensions = new DimensionPalette();
|
|
addedNodes.forEach((node, loc) -> dimensions.encode(loc.getFirst().dimension));
|
|
addedEdgePoints.forEach(ep -> ep.edgeLocation.forEach(loc -> dimensions.encode(loc.dimension)));
|
|
dimensions.send(buffer);
|
|
|
|
buffer.writeVarInt(removedNodes.size());
|
|
removedNodes.forEach(buffer::writeVarInt);
|
|
|
|
buffer.writeVarInt(addedNodes.size());
|
|
addedNodes.forEach((node, loc) -> {
|
|
buffer.writeVarInt(node);
|
|
loc.getFirst()
|
|
.send(buffer, dimensions);
|
|
VecHelper.write(loc.getSecond(), buffer);
|
|
});
|
|
|
|
buffer.writeVarInt(addedEdges.size());
|
|
addedEdges.forEach(pair -> {
|
|
pair.getFirst().getFirst()
|
|
.forEach(buffer::writeVarInt);
|
|
buffer.writeUtf(pair.getFirst().getSecond().id.toString());
|
|
BezierConnection turn = pair.getSecond();
|
|
buffer.writeBoolean(turn != null);
|
|
if (turn != null)
|
|
turn.write(buffer);
|
|
});
|
|
|
|
buffer.writeVarInt(addedEdgePoints.size());
|
|
addedEdgePoints.forEach(ep -> ep.write(buffer, dimensions));
|
|
|
|
buffer.writeVarInt(removedEdgePoints.size());
|
|
removedEdgePoints.forEach(buffer::writeUUID);
|
|
|
|
buffer.writeVarInt(updatedEdgeData.size());
|
|
for (Entry<Couple<Integer>, Pair<Integer, List<UUID>>> entry : updatedEdgeData.entrySet()) {
|
|
entry.getKey()
|
|
.forEach(buffer::writeInt);
|
|
Pair<Integer, List<UUID>> pair = entry.getValue();
|
|
buffer.writeVarInt(pair.getFirst());
|
|
List<UUID> list = pair.getSecond();
|
|
buffer.writeVarInt(list.size());
|
|
list.forEach(buffer::writeUUID);
|
|
}
|
|
|
|
buffer.writeVarInt(splitSubGraphs.size());
|
|
splitSubGraphs.forEach((node, p) -> {
|
|
buffer.writeVarInt(node);
|
|
buffer.writeInt(p.getFirst());
|
|
buffer.writeUUID(p.getSecond());
|
|
});
|
|
}
|
|
|
|
@Override
|
|
protected void handle(GlobalRailwayManager manager, TrackGraph graph) {
|
|
if (packetDeletesGraph) {
|
|
manager.removeGraph(graph);
|
|
return;
|
|
}
|
|
|
|
if (fullWipe) {
|
|
manager.removeGraph(graph);
|
|
graph = Create.RAILWAYS.sided(null)
|
|
.getOrCreateGraph(graphId, netId);
|
|
}
|
|
|
|
for (int nodeId : removedNodes) {
|
|
TrackNode node = graph.getNode(nodeId);
|
|
if (node != null)
|
|
graph.removeNode(null, node.getLocation());
|
|
}
|
|
|
|
for (Entry<Integer, Pair<TrackNodeLocation, Vec3>> entry : addedNodes.entrySet()) {
|
|
Integer nodeId = entry.getKey();
|
|
Pair<TrackNodeLocation, Vec3> nodeLocation = entry.getValue();
|
|
graph.loadNode(nodeLocation.getFirst(), nodeId, nodeLocation.getSecond());
|
|
}
|
|
|
|
for (Pair<Pair<Couple<Integer>, TrackMaterial>, BezierConnection> pair : addedEdges) {
|
|
Couple<TrackNode> nodes = pair.getFirst().getFirst()
|
|
.map(graph::getNode);
|
|
TrackNode node1 = nodes.getFirst();
|
|
TrackNode node2 = nodes.getSecond();
|
|
if (node1 != null && node2 != null)
|
|
graph.putConnection(node1, node2, new TrackEdge(node1, node2, pair.getSecond(), pair.getFirst().getSecond()));
|
|
}
|
|
|
|
for (TrackEdgePoint edgePoint : addedEdgePoints)
|
|
graph.edgePoints.put(edgePoint.getType(), edgePoint);
|
|
|
|
for (UUID uuid : removedEdgePoints)
|
|
for (EdgePointType<?> type : EdgePointType.TYPES.values())
|
|
graph.edgePoints.remove(type, uuid);
|
|
|
|
handleEdgeData(manager, graph);
|
|
|
|
if (!splitSubGraphs.isEmpty())
|
|
graph.findDisconnectedGraphs(null, splitSubGraphs)
|
|
.forEach(manager::putGraph);
|
|
}
|
|
|
|
protected void handleEdgeData(GlobalRailwayManager manager, TrackGraph graph) {
|
|
for (Entry<Couple<Integer>, Pair<Integer, List<UUID>>> entry : updatedEdgeData.entrySet()) {
|
|
List<UUID> idList = entry.getValue()
|
|
.getSecond();
|
|
int groupType = entry.getValue()
|
|
.getFirst();
|
|
|
|
Couple<TrackNode> nodes = entry.getKey()
|
|
.map(graph::getNode);
|
|
if (nodes.either(Objects::isNull))
|
|
continue;
|
|
TrackEdge edge = graph.getConnectionsFrom(nodes.getFirst())
|
|
.get(nodes.getSecond());
|
|
if (edge == null)
|
|
continue;
|
|
|
|
EdgeData edgeData = new EdgeData(edge);
|
|
if (groupType == NULL_GROUP)
|
|
edgeData.setSingleSignalGroup(null, null);
|
|
else if (groupType == PASSIVE_GROUP)
|
|
edgeData.setSingleSignalGroup(null, EdgeData.passiveGroup);
|
|
else
|
|
edgeData.setSingleSignalGroup(null, idList.get(0));
|
|
|
|
List<TrackEdgePoint> points = edgeData.getPoints();
|
|
edge.edgeData = edgeData;
|
|
|
|
for (int i = groupType == GROUP ? 1 : 0; i < idList.size(); i++) {
|
|
UUID uuid = idList.get(i);
|
|
for (EdgePointType<?> type : EdgePointType.TYPES.values()) {
|
|
TrackEdgePoint point = graph.edgePoints.get(type, uuid);
|
|
if (point == null)
|
|
continue;
|
|
points.add(point);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void syncEdgeData(TrackNode node1, TrackNode node2, TrackEdge edge) {
|
|
Couple<Integer> key = Couple.create(node1.getNetId(), node2.getNetId());
|
|
List<UUID> list = new ArrayList<>();
|
|
EdgeData edgeData = edge.getEdgeData();
|
|
int groupType = edgeData.hasSignalBoundaries() ? NULL_GROUP
|
|
: EdgeData.passiveGroup.equals(edgeData.getSingleSignalGroup()) ? PASSIVE_GROUP : GROUP;
|
|
if (groupType == GROUP)
|
|
list.add(edgeData.getSingleSignalGroup());
|
|
for (TrackEdgePoint point : edgeData.getPoints())
|
|
list.add(point.getId());
|
|
updatedEdgeData.put(key, Pair.of(groupType, list));
|
|
}
|
|
|
|
}
|