Tunnel removal bugfixes

Author: robotgryphon

src/main/java/dev/compactmods/machines/machine/CompactMachineBlockEntity.java

@@ -11,6 +11,8 @@
 import dev.compactmods.machines.machine.data.CompactMachineData;
 import dev.compactmods.machines.machine.data.MachineToRoomConnections;
 import dev.compactmods.machines.room.data.CompactRoomData;
+import dev.compactmods.machines.tunnel.TunnelWallEntity;
+import dev.compactmods.machines.tunnel.data.RoomTunnelData;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
 import net.minecraft.nbt.CompoundTag;
@@ -49,18 +51,51 @@ public CompactMachineBlockEntity(BlockPos pos, BlockState state) {
     @Override
     public <T> LazyOptional<T> getCapability(@Nonnull Capability<T> cap, @Nullable Direction side) {
         if (cap == Capabilities.ROOM) return room.cast();
-        if (cap == Capabilities.ROOM_CAPS) return caps.cast();
 
-        return caps.lazyMap(c -> c.getCapability(cap, side))
-                .orElse(super.getCapability(cap, side));
+        if(level instanceof ServerLevel sl) {
+            return room.map(r -> {
+                var roomId = r.getChunk();
+                try {
+                    final var serv = sl.getServer();
+
+                    final var tunnels = RoomTunnelData.get(serv, roomId);
+                    final var graph = tunnels.getGraph();
+
+                    final var supportingTunnels = graph.getTunnelsSupporting(machineId, side, cap);
+                    final var firstSupported = supportingTunnels.findFirst();
+                    if (firstSupported.isEmpty())
+                        return super.getCapability(cap, side);
+
+                    final var compact = serv.getLevel(Registration.COMPACT_DIMENSION);
+                    if(compact == null)
+                        throw new MissingDimensionException();
+
+                    if(compact.getBlockEntity(firstSupported.get()) instanceof TunnelWallEntity tunnel) {
+                        return tunnel.getCapability(cap, side);
+                    } else {
+                        return super.getCapability(cap, side);
+                    }
+                } catch (MissingDimensionException e) {
+                    CompactMachines.LOGGER.fatal(e);
+                    return super.getCapability(cap, side);
+                }
+            }).orElse(super.getCapability(cap, side));
+        }
+
+        return super.getCapability(cap, side);
     }
 
     @Nullable
     private IMachineRoom getRoom() {
         if (level instanceof ServerLevel sl) {
             return getInternalChunkPos().map(c -> {
-                var inChunk = sl.getChunk(c.x, c.z);
-                return inChunk.getCapability(Capabilities.ROOM).orElseThrow(RuntimeException::new);
+                final var compact = sl.getServer().getLevel(Registration.COMPACT_DIMENSION);
+                if(compact != null) {
+                    var inChunk = compact.getChunk(c.x, c.z);
+                    return inChunk.getCapability(Capabilities.ROOM).orElseThrow(RuntimeException::new);
+                }
+
+                return null;
             }).orElse(null);
         }
 
@@ -70,9 +105,12 @@ private IMachineRoom getRoom() {
     @Nullable
     private IRoomCapabilities getRoomCapabilities() {
         if (level instanceof ServerLevel sl) {
-            return getInternalChunkPos().map(c -> {
+            getInternalChunkPos().map(c -> {
                 var inChunk = sl.getChunk(c.x, c.z);
-                return inChunk.getCapability(Capabilities.ROOM_CAPS).orElseThrow(RuntimeException::new);
+
+                CompactMachines.LOGGER.debug(inChunk.toString());
+
+                return null;
             }).orElse(null);
         }
 

src/main/java/dev/compactmods/machines/tunnel/TunnelWallBlock.java

@@ -1,5 +1,6 @@
 package dev.compactmods.machines.tunnel;
 
+import dev.compactmods.machines.CompactMachines;
 import dev.compactmods.machines.api.core.Messages;
 import dev.compactmods.machines.api.tunnels.TunnelDefinition;
 import dev.compactmods.machines.api.tunnels.lifecycle.ITunnelTeardown;
@@ -58,7 +59,7 @@ public static Optional<TunnelDefinition> getTunnelInfo(BlockGetter world, BlockP
         if (tile == null)
             return Optional.empty();
 
-        return Optional.of(tile.getTunnelType());
+        return Optional.ofNullable(tile.getTunnelType());
     }
 
     @Override
@@ -129,7 +130,14 @@ public InteractionResult use(BlockState state, Level level, BlockPos pos, Player
                 teardown.teardown(new TunnelPosition(serverLevel, pos, tunnelWallSide), tunnel.getTunnel(), TeardownReason.REMOVED);
             }
 
-            // todo tunnels.ifPresent(t -> t.unregister(pos));
+            try {
+                final var tunnels = RoomTunnelData.get(serverLevel.getServer(), new ChunkPos(pos));
+                final var tunnelGraph = tunnels.getGraph();
+
+                tunnelGraph.unregister(pos);
+            } catch (MissingDimensionException e) {
+                CompactMachines.LOGGER.fatal(e);
+            }
         } else {
             // Rotate tunnel
             Direction dir = state.getValue(CONNECTED_SIDE);
@@ -170,4 +178,6 @@ public InteractionResult use(BlockState state, Level level, BlockPos pos, Player
 
         return InteractionResult.SUCCESS;
     }
+
+    // todo - breaking block unregisters tunnel info
 }

src/main/java/dev/compactmods/machines/tunnel/TunnelWallEntity.java

@@ -156,7 +156,7 @@ public <T> LazyOptional<T> getCapability(@Nonnull Capability<T> cap, @Nullable D
         if (level == null || level.isClientSide)
             return super.getCapability(cap, side);
 
-        if (side != null && side != getTunnelSide())
+        if (side != null && side != getConnectedSide())
             return super.getCapability(cap, side);
 
         if (cap == Capabilities.TUNNEL_CONNECTION)

src/main/java/dev/compactmods/machines/tunnel/graph/TunnelConnectionGraph.java

@@ -228,6 +228,8 @@ public Stream<IGraphNode> nodes() {
 
     @Override
     public CompoundTag serializeNBT() {
+        cleanupOrphans();
+
         CompoundTag tag = new CompoundTag();
 
         HashMap<IGraphNode, UUID> nodeIds = new HashMap<>();
@@ -454,4 +456,58 @@ public Stream<BlockPos> getMachineTunnels(int machine, TunnelDefinition type) {
                 .filter(position -> connectedMachine(position).map(m -> m == machine).orElse(false))
                 .map(BlockPos::immutable);
     }
+
+    public void unregister(BlockPos pos) {
+        if(!hasTunnel(pos))
+            return;
+
+        final var existing = tunnels.get(pos);
+        graph.removeNode(existing);
+        tunnels.remove(pos);
+
+        cleanupOrphanedTypes();
+        cleanupOrphanedMachines();
+    }
+
+    private void cleanupOrphans() {
+        cleanupOrphanedTunnels();
+        cleanupOrphanedTypes();
+        cleanupOrphanedMachines();
+    }
+
+    private void cleanupOrphanedTypes() {
+        HashSet<ResourceLocation> removedTypes = new HashSet<>();
+        tunnelTypes.forEach((type, node) -> {
+            if(graph.degree(node) == 0) {
+                graph.removeNode(node);
+                removedTypes.add(type);
+            }
+        });
+
+        removedTypes.forEach(tunnelTypes::remove);
+    }
+
+    private void cleanupOrphanedTunnels() {
+        HashSet<BlockPos> removed = new HashSet<>();
+        tunnels.forEach((pos, node) -> {
+            if(graph.degree(node) == 0) {
+                graph.removeNode(node);
+                removed.add(pos);
+            }
+        });
+
+        removed.forEach(tunnels::remove);
+    }
+
+    private void cleanupOrphanedMachines() {
+        HashSet<Integer> removed = new HashSet<>();
+        machines.forEach((machine, node) -> {
+            if(graph.degree(node) == 0) {
+                graph.removeNode(node);
+                removed.add(machine);
+            }
+        });
+
+        removed.forEach(machines::remove);
+    }
 }