fix: bump minestom, for now stop using Palette#setAll until further investigation

mworzala · mworzala · commit 089e6a4353e3 · 2025-01-25T13:06:49.000-05:00
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
@@ -1,7 +1,7 @@
 metadata.format.version = "1.1"
 
 [versions]
-minestom = "d760a60a5c"
+minestom = "96543a894f"
 zstd = "1.5.5-3"
 fastutil = "8.5.12"
 
diff --git a/src/main/java/net/hollowcube/polar/PolarLoader.java b/src/main/java/net/hollowcube/polar/PolarLoader.java
@@ -219,10 +219,14 @@ private void loadSection(@NotNull PolarSection sectionData, @NotNull Section sec
             section.blockPalette().fill(blockPalette[0].stateId());
         } else {
             final var paletteData = sectionData.blockData();
-            section.blockPalette().setAll((x, y, z) -> {
-                int index = y * CHUNK_SECTION_SIZE * CHUNK_SECTION_SIZE + z * CHUNK_SECTION_SIZE + x;
-                return blockPalette[paletteData[index]].stateId();
-            });
+            for (int y = 0; y < CHUNK_SECTION_SIZE; y++) {
+                for (int z = 0; z < CHUNK_SECTION_SIZE; z++) {
+                    for (int x = 0; x < CHUNK_SECTION_SIZE; x++) {
+                        int index = y * CHUNK_SECTION_SIZE * CHUNK_SECTION_SIZE + z * CHUNK_SECTION_SIZE + x;
+                        section.blockPalette().set(x, y, z, blockPalette[paletteData[index]].stateId());
+                    }
+                }
+            }
         }
 
         // Biomes
@@ -242,18 +246,22 @@ private void loadSection(@NotNull PolarSection sectionData, @NotNull Section sec
             section.biomePalette().fill(biomePalette[0]);
         } else {
             final var paletteData = sectionData.biomeData();
-            section.biomePalette().setAll((x, y, z) -> {
-                int index = x / 4 + (z / 4) * 4 + (y / 4) * 16;
-
-                var paletteIndex = paletteData[index];
-                if (paletteIndex >= biomePalette.length) {
-                    logger.error("Invalid biome palette index. This is probably a corrupted world, " +
-                            "but it has been loaded with plains instead. No data has been written.");
-                    return PLAINS_BIOME_ID;
-                }
+            for (int y = 0; y < CHUNK_SECTION_SIZE; y++) {
+                for (int z = 0; z < CHUNK_SECTION_SIZE; z++) {
+                    for (int x = 0; x < CHUNK_SECTION_SIZE; x++) {
+                        int index = x / 4 + (z / 4) * 4 + (y / 4) * 16;
+
+                        var paletteIndex = paletteData[index];
+                        if (paletteIndex >= biomePalette.length) {
+                            logger.error("Invalid biome palette index. This is probably a corrupted world, " +
+                                    "but it has been loaded with plains instead. No data has been written.");
+                            section.biomePalette().set(x, y, z, PLAINS_BIOME_ID);
+                        }
 
-                return biomePalette[paletteIndex];
-            });
+                        section.biomePalette().set(x, y, z, biomePalette[paletteIndex]);
+                    }
+                }
+            }
         }
 
         // Light
diff --git a/src/main/java/net/hollowcube/polar/PolarSection.java b/src/main/java/net/hollowcube/polar/PolarSection.java
@@ -102,7 +102,6 @@ public int[] biomeData() {
     }
 
     public byte[] blockLight() {
-        assert blockLight != null : "must check hasBlockLightData() before calling blockLight()";
         return blockLight;
     }
 
@@ -111,7 +110,6 @@ public byte[] blockLight() {
     }
 
     public byte[] skyLight() {
-        assert skyLight != null : "must check hasSkyLightData() before calling skyLight()";
         return skyLight;
     }
 }
diff --git a/src/main/java/net/hollowcube/polar/StreamingPolarLoader.java b/src/main/java/net/hollowcube/polar/StreamingPolarLoader.java
@@ -176,10 +176,18 @@ private void readSection(@NotNull NetworkBuffer buffer, @NotNull Section section
             var bitsPerEntry = (int) Math.ceil(Math.log(blockPalette.length) / Math.log(2));
             PaletteUtil.unpack(blockData, rawBlockData, bitsPerEntry);
 
-            section.blockPalette().setAll((x, y, z) -> {
-                int index = y * CHUNK_SECTION_SIZE * CHUNK_SECTION_SIZE + z * CHUNK_SECTION_SIZE + x;
-                return blockPalette[blockData[index]];
-            });
+            for (int y = 0; y < CHUNK_SECTION_SIZE; y++) {
+                for (int z = 0; z < CHUNK_SECTION_SIZE; z++) {
+                    for (int x = 0; x < CHUNK_SECTION_SIZE; x++) {
+                        int index = y * CHUNK_SECTION_SIZE * CHUNK_SECTION_SIZE + z * CHUNK_SECTION_SIZE + x;
+                        section.blockPalette().set(x, y, z, blockPalette[blockData[index]]);
+                    }
+                }
+            }
+//            section.blockPalette().setAll((x, y, z) -> {
+//                int index = y * CHUNK_SECTION_SIZE * CHUNK_SECTION_SIZE + z * CHUNK_SECTION_SIZE + x;
+//                return blockPalette[blockData[index]];
+//            });
 
             // Below was some previous logic, leaving it around for now I would like to fix it up.
 //            System.out.println(Arrays.toString(blockPalette));
@@ -202,10 +210,18 @@ private void readSection(@NotNull NetworkBuffer buffer, @NotNull Section section
             var bitsPerEntry = (int) Math.ceil(Math.log(biomePalette.length) / Math.log(2));
             PaletteUtil.unpack(biomeData, rawBiomeData, bitsPerEntry);
 
-            section.biomePalette().setAll((x, y, z) -> {
-                int index = x / 4 + (z / 4) * 4 + (y / 4) * 16;
-                return biomePalette[biomeData[index]];
-            });
+            for (int y = 0; y < 4; y++) {
+                for (int z = 0; z < 4; z++) {
+                    for (int x = 0; x < 4; x++) {
+                        int index = x + z * 4 + y * 16;
+                        section.biomePalette().set(x, y, z, biomePalette[biomeData[index]]);
+                    }
+                }
+            }
+//            section.biomePalette().setAll((x, y, z) -> {
+//                int index = x / 4 + (z / 4) * 4 + (y / 4) * 16;
+//                return biomePalette[biomeData[index]];
+//            });
 
 //            var rawBiomeData = buffer.read(LONG_ARRAY);
 //            var bitsPerEntry = (int) Math.ceil(Math.log(biomePalette.length) / Math.log(2));
diff --git a/src/test/java/net/hollowcube/polar/TestBigPaletteReadWrite.java b/src/test/java/net/hollowcube/polar/TestBigPaletteReadWrite.java
@@ -0,0 +1,109 @@
+package net.hollowcube.polar;
+
+import net.minestom.server.MinecraftServer;
+import net.minestom.server.instance.InstanceContainer;
+import net.minestom.server.instance.block.Block;
+import net.minestom.server.world.DimensionType;
+import org.junit.jupiter.api.Test;
+
+import java.io.ByteArrayInputStream;
+import java.nio.channels.Channels;
+import java.util.Random;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class TestBigPaletteReadWrite {
+
+    static {
+        MinecraftServer.init();
+    }
+
+    @Test
+    void testPackUnpackDirect() {
+        var ints = new int[4096];
+        for (int i = 0; i < 510; i++) {
+            ints[i] = i;
+        }
+        var bitsPerEntry = 9;
+
+        var longs = PaletteUtil.pack(ints, bitsPerEntry);
+        var out = new int[ints.length];
+        PaletteUtil.unpack(out, longs, bitsPerEntry);
+
+        assertArrayEquals(ints, out);
+    }
+
+    @Test
+    void testStreamLoader() {
+        var instance = new InstanceContainer(UUID.randomUUID(), DimensionType.OVERWORLD);
+
+        var random = new Random(22);
+        int blockCount = 256;
+
+        for (int y = 0; y < 16; y++) {
+            for (int z = 0; z < 16; z++) {
+                for (int x = 0; x < 16; x++) {
+                    var block = Block.fromStateId(random.nextInt(blockCount));
+                    instance.setBlock(x, y, z, block);
+                }
+            }
+        }
+
+        var loader = new PolarLoader(new PolarWorld());
+        instance.setChunkLoader(loader);
+        instance.saveChunksToStorage().join();
+        var worldBytes = PolarWriter.write(loader.world());
+
+        var loadInstance = new InstanceContainer(UUID.randomUUID(), DimensionType.OVERWORLD);
+        PolarLoader.streamLoad(loadInstance, Channels.newChannel(new ByteArrayInputStream(worldBytes)),
+                worldBytes.length, null, null, false).join();
+
+        random = new Random(22);
+        for (int y = 0; y < 16; y++) {
+            for (int z = 0; z < 16; z++) {
+                for (int x = 0; x < 16; x++) {
+                    var block = Block.fromStateId(random.nextInt(blockCount));
+                    assertEquals(block, loadInstance.getBlock(x, y, z));
+                }
+            }
+        }
+    }
+
+    @Test
+    void testLegacyLoader() {
+        var instance = new InstanceContainer(UUID.randomUUID(), DimensionType.OVERWORLD);
+
+        var random = new Random(22);
+        int blockCount = 256;
+
+        for (int y = 0; y < 16; y++) {
+            for (int z = 0; z < 16; z++) {
+                for (int x = 0; x < 16; x++) {
+                    var block = Block.fromStateId(random.nextInt(blockCount));
+                    instance.setBlock(x, y, z, block);
+                }
+            }
+        }
+
+        var loader = new PolarLoader(new PolarWorld());
+        instance.setChunkLoader(loader);
+        instance.saveChunksToStorage().join();
+        var worldBytes = PolarWriter.write(loader.world());
+
+        var loadInstance = new InstanceContainer(UUID.randomUUID(), DimensionType.OVERWORLD);
+        loadInstance.setChunkLoader(new PolarLoader(PolarReader.read(worldBytes)));
+        loadInstance.loadChunk(0, 0).join();
+
+        random = new Random(22);
+        for (int y = 0; y < 16; y++) {
+            for (int z = 0; z < 16; z++) {
+                for (int x = 0; x < 16; x++) {
+                    var block = Block.fromStateId(random.nextInt(blockCount));
+                    assertEquals(block, loadInstance.getBlock(x, y, z));
+                }
+            }
+        }
+    }
+}
diff --git a/src/test/java/net/hollowcube/polar/TestUserDataWriteRead.java b/src/test/java/net/hollowcube/polar/TestUserDataWriteRead.java
@@ -6,7 +6,6 @@
 import net.minestom.server.world.DimensionType;
 import org.junit.jupiter.api.Test;
 
-import java.nio.ByteBuffer;
 import java.util.Arrays;
 import java.util.List;
 import java.util.UUID;
@@ -32,15 +31,15 @@ void testWriteRead() {
         var wa = new UpdateTimeWorldAccess();
         var loader = new PolarLoader(world).setWorldAccess(wa);
         var instance = new InstanceContainer(UUID.randomUUID(), DimensionType.OVERWORLD, loader);
-        var chunk = loader.loadChunk(instance, 0, 0).join();
+        var chunk = loader.loadChunk(instance, 0, 0);
 
         loader.saveChunk(chunk);
 
         var newPolarChunk = world.chunkAt(0, 0);
-        var savedTime = new NetworkBuffer(ByteBuffer.wrap(newPolarChunk.userData())).read(NetworkBuffer.LONG);
+        var savedTime = NetworkBuffer.wrap(newPolarChunk.userData(), 0, newPolarChunk.userData().length).read(NetworkBuffer.LONG);
         assertEquals(wa.saveTime, savedTime);
 
-        loader.loadChunk(instance, 0, 0).join();
+        loader.loadChunk(instance, 0, 0);
         assertEquals(wa.loadTime, savedTime);
     }
 
diff --git a/src/test/java/net/hollowcube/polar/demo/DemoServer.java b/src/test/java/net/hollowcube/polar/demo/DemoServer.java
@@ -46,7 +46,7 @@ public static void main(String[] args) throws Exception {
                     event.getPlayer().setGameMode(GameMode.CREATIVE);
                 })
                 .addListener(PlayerChatEvent.class, event -> {
-                    if (!event.getMessage().equals("save")) return;
+                    if (!event.getRawMessage().equals("save")) return;
 
                     var start = System.currentTimeMillis();
                     instance.saveChunksToStorage().join();

Original file line number	Diff line number	Diff line change
`@@ -102,7 +102,6 @@ public int[] biomeData() {`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`public byte[] blockLight() {`
`105`		`- assert blockLight != null : "must check hasBlockLightData() before calling blockLight()";`
`106`	`105`	`return blockLight;`
`107`	`106`	`}`
`108`	`107`
`@@ -111,7 +110,6 @@ public byte[] blockLight() {`
`111`	`110`	`}`
`112`	`111`
`113`	`112`	`public byte[] skyLight() {`
`114`		`- assert skyLight != null : "must check hasSkyLightData() before calling skyLight()";`
`115`	`113`	`return skyLight;`
`116`	`114`	`}`
`117`	`115`	`}`