Minestom · tacf · Mar 27, 2026
diff --git a/.gitignore b/.gitignore
@@ -29,6 +29,7 @@ hs_err_pid*
 .idea/
 out/
 .gradle/
+.gradel-home/
 
 # Minestom
 /minecraft_data/

diff --git a/blocks/src/main/java/net/minestom/vanilla/blocks/behaviours/BedBlockBehaviour.java b/blocks/src/main/java/net/minestom/vanilla/blocks/behaviours/BedBlockBehaviour.java
@@ -4,18 +4,22 @@
 import net.minestom.server.coordinate.Point;
 import net.minestom.server.entity.EntityPose;
 import net.minestom.server.entity.Player;
-import net.minestom.server.entity.metadata.PlayerMeta;
+import net.minestom.server.entity.metadata.avatar.PlayerMeta;
 import net.minestom.server.instance.Instance;
 import net.minestom.server.instance.block.Block;
 import net.minestom.server.item.ItemStack;
 import net.minestom.server.utils.Direction;
 import net.minestom.server.utils.MathUtils;
 import net.minestom.server.utils.time.TimeUnit;
 import net.minestom.server.world.DimensionType;
+import net.minestom.server.world.attribute.BedRule;
+import net.minestom.server.world.attribute.EnvironmentAttribute;
+import net.minestom.server.world.attribute.EnvironmentAttributeMap;
 import net.minestom.vanilla.blocks.VanillaBlockBehaviour;
 import net.minestom.vanilla.blocks.VanillaBlocks;
 import net.minestom.vanilla.instance.VanillaExplosion;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 @SuppressWarnings("UnstableApiUsage")
 public class BedBlockBehaviour extends VanillaBlockBehaviour {
@@ -76,10 +80,26 @@ public boolean onInteract(@NotNull Interaction interaction) {
         Instance instance = interaction.getInstance();
         Point pos = interaction.getBlockPosition();
         Player player = interaction.getPlayer();
+
         var dimensionKey = instance.getDimensionType();
         DimensionType dimension = MinecraftServer.getDimensionTypeRegistry().get(dimensionKey);
+        if (dimension == null) {
+            return false;
+        }
+
+        BedRule bedRule = resolveBedRule(dimension);
+        if (bedRule == null) {
+            return false;
+        }
+
+        // Closest replacement for old dimension.bedWorks():
+        // beds "work" if they do not explode in this dimension.
+        if (!bedRule.explodes()) {
+            // Optional: only allow actual sleeping when the rule says so
+            if (bedRule.canSleep() == BedRule.Rule.NEVER) {
+                return false;
+            }
 
-        if (dimension.bedWorks()) {
             // TODO: make player sleep
             // TODO: checks for mobs
             // TODO: check for day
@@ -116,6 +136,21 @@ public boolean onInteract(@NotNull Interaction interaction) {
         return true;
     }
 
+    @SuppressWarnings("unchecked")
+    private static @Nullable BedRule resolveBedRule(@NotNull DimensionType dimension) {
+        EnvironmentAttributeMap.Entry<?, ?> rawEntry =
+                dimension.attributes().entries().get(EnvironmentAttribute.BED_RULE);
+
+        if (rawEntry == null) {
+            return null;
+        }
+
+        EnvironmentAttributeMap.Entry<BedRule, Object> entry =
+                (EnvironmentAttributeMap.Entry<BedRule, Object>) rawEntry;
+
+        return entry.modifier().modify(null, entry.argument());
+    }
+
     @Override
     public void onDestroy(@NotNull Destroy destroy) {
         Instance instance = destroy.getInstance();

diff --git a/blocks/src/main/java/net/minestom/vanilla/blocks/behaviours/EndPortalBlockBehaviour.java b/blocks/src/main/java/net/minestom/vanilla/blocks/behaviours/EndPortalBlockBehaviour.java
@@ -59,7 +59,7 @@ public void onTouch(@NotNull Touch touch) {
                 spawnPoint = new Pos(obsidianPlatformX, yLevel, obsidianPlatformZ);
             }
 
-            if (targetDimension.effects().equals("the_end")) {
+            if (targetInstance.getDimensionType().equals(DimensionType.THE_END)) {
                 for (int x = -1; x <= 1; x++) {
                     for (int z = -1; z <= 1; z++) {
                         targetInstance.loadChunk(obsidianPlatformX / 16 + x, obsidianPlatformZ / 16 + z);

diff --git a/blocks/src/main/java/net/minestom/vanilla/blocks/behaviours/JukeboxBlockBehaviour.java b/blocks/src/main/java/net/minestom/vanilla/blocks/behaviours/JukeboxBlockBehaviour.java
@@ -12,7 +12,6 @@
 import net.minestom.server.instance.block.Block;
 import net.minestom.server.instance.block.jukebox.JukeboxSong;
 import net.minestom.server.item.ItemStack;
-import net.minestom.server.registry.DynamicRegistry;
 import net.minestom.server.tag.Tag;
 import net.minestom.server.worldevent.WorldEvent;
 import net.minestom.vanilla.blocks.VanillaBlockBehaviour;
@@ -84,8 +83,8 @@ public boolean onInteract(@NotNull Interaction interaction) {
 
         InventoryManipulation.consumeItemIfNotCreative(player, heldItem, hand);
 
-        JukeboxSong song = heldItem.get(DataComponents.JUKEBOX_PLAYABLE).holder().resolve(MinecraftServer.getJukeboxSongRegistry());
-        DynamicRegistry.Key<JukeboxSong> songKey = MinecraftServer.getJukeboxSongRegistry().getKey(song);
+        JukeboxSong song = heldItem.get(DataComponents.JUKEBOX_PLAYABLE).resolve(MinecraftServer.getJukeboxSongRegistry());
+        net.minestom.server.registry.@Nullable RegistryKey<JukeboxSong> songKey = MinecraftServer.getJukeboxSongRegistry().getKey(song);
         int songId = MinecraftServer.getJukeboxSongRegistry().getId(songKey);
 
         // TODO: Group packet?

diff --git a/blocks/src/main/java/net/minestom/vanilla/blocks/behaviours/NetherPortalBlockBehaviour.java b/blocks/src/main/java/net/minestom/vanilla/blocks/behaviours/NetherPortalBlockBehaviour.java
@@ -141,8 +141,7 @@ private void attemptTeleport(Instance instance, Entity touching, Block block, lo
         double targetZ = position.z() / 8;
 
         var key = instance.getDimensionType();
-        DimensionType dimension = MinecraftServer.getDimensionTypeRegistry().get(key);
-        if (dimension.effects().equals("nether")) {
+        if (key == DimensionType.THE_NETHER) {
             targetDimension = MinecraftServer.getDimensionTypeRegistry().get(DimensionType.OVERWORLD);
             targetX = position.x() * 8;
             targetZ = position.z() * 8;

diff --git a/build.gradle.kts b/build.gradle.kts
@@ -2,24 +2,26 @@ plugins {
     java
     `java-library`
     `maven-publish`
-    id("com.github.harbby.gradle.serviceloader") version ("1.1.8")
-    id("io.github.goooler.shadow") version ("8.1.8")
+    id("com.github.harbby.gradle.serviceloader") version ("1.1.9")
+    id("com.gradleup.shadow") version "8.3.10" apply false
 }
 
 subprojects {
-
     plugins.apply("java")
     plugins.apply("java-library")
     plugins.apply("maven-publish")
     plugins.apply("com.github.harbby.gradle.serviceloader")
-    plugins.apply("io.github.goooler.shadow")
+    plugins.apply("com.gradleup.shadow")
 
     group = "net.minestom.vanilla"
     version = "indev"
 
     java {
-        sourceCompatibility = JavaVersion.VERSION_21
-        targetCompatibility = JavaVersion.VERSION_21
+        toolchain {
+            languageVersion = JavaLanguageVersion.of(25)
+        }
+        sourceCompatibility = JavaVersion.VERSION_25
+        targetCompatibility = JavaVersion.VERSION_25
 
 //        withJavadocJar()
         withSourcesJar()
@@ -37,13 +39,38 @@ subprojects {
         gradleVersion = rootProject.gradle.gradleVersion
     }
 
+    tasks.withType<JavaCompile>().configureEach {
+        options.release = 25
+    }
+
+    tasks.withType<Test>().configureEach {
+        javaLauncher = javaToolchains.launcherFor {
+            languageVersion = JavaLanguageVersion.of(25)
+        }
+    }
+
+    tasks.withType<JavaExec>().configureEach {
+        javaLauncher = javaToolchains.launcherFor {
+            languageVersion = JavaLanguageVersion.of(25)
+        }
+    }
+
+    tasks.withType<Javadoc>().configureEach {
+        javadocTool = javaToolchains.javadocToolFor {
+            languageVersion = JavaLanguageVersion.of(25)
+        }
+    }
+
     repositories {
         mavenCentral()
         maven(url = "https://jitpack.io")
         mavenLocal()
     }
 
     dependencies {
+        testImplementation(platform("org.junit:junit-bom:5.13.4"))
+        testImplementation("org.junit.jupiter:junit-jupiter")
+        testRuntimeOnly("org.junit.platform:junit-platform-launcher")
     }
 
     publishing {

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
@@ -18,6 +18,8 @@ dependencies {
     api("com.squareup.moshi:moshi:1.14.0")
     api("com.squareup.moshi:moshi-adapters:1.14.0")
 
+    api("it.unimi.dsi:fastutil:8.5.18")
+
     // Tests
     testImplementation(platform("org.junit:junit-bom:5.9.1"))
     testImplementation("org.junit.jupiter:junit-jupiter")

diff --git a/datapack-loading/src/main/java/net/minestom/vanilla/datapack/DatapackLoader.java b/datapack-loading/src/main/java/net/minestom/vanilla/datapack/DatapackLoader.java
@@ -129,6 +129,7 @@ public void toJson(@NotNull JsonWriter writer, JsonUtils.SingleOrList<?> value)
         register(builder, Datapack.Tag.TagValue.ObjectOrTagReference.class, Datapack.Tag.TagValue.ObjectOrTagReference::fromJson);
         register(builder, Biome.Effects.Particle.Options.class, Biome.Effects.Particle.Options::fromJson);
         register(builder, Biome.Sound.class, Biome.Sound::fromJson);
+        register(builder, Biome.Color.class, Biome.Color::fromJson);
         register(builder, Carver.class, Carver::fromJson);
         register(builder, FloatProvider.class, FloatProvider::fromJson);
         register(builder, Biome.CarversList.class, Biome.CarversList::fromJson);

diff --git a/datapack-loading/src/main/java/net/minestom/vanilla/datapack/dimension/DimensionType.java b/datapack-loading/src/main/java/net/minestom/vanilla/datapack/dimension/DimensionType.java
@@ -4,11 +4,9 @@
 
 // {
 //  "ambient_light": 0.0,
-//  "bed_works": true,
 //  "coordinate_scale": 1.0,
 //  "effects": "minecraft:overworld",
 //  "has_ceiling": false,
-//  "has_raids": true,
 //  "has_skylight": true,
 //  "height": 384,
 //  "infiniburn": "#minecraft:infiniburn_overworld",
@@ -29,21 +27,14 @@
 //}
 public record DimensionType(
         double ambient_light,
-        boolean bed_works,
         double coordinate_scale,
-        String effects,
         boolean has_ceiling,
-        boolean has_raids,
         boolean has_skylight,
         int height,
         String infiniburn,
         int logical_height,
         int min_y,
         int monster_spawn_block_light_limit,
-        NumberProvider.Int monster_spawn_light_level,
-        boolean natural,
-        boolean piglin_safe,
-        boolean respawn_anchor_works,
-        boolean ultrawarm
+        NumberProvider.Int monster_spawn_light_level
 ) {
 }
diff --git a/datapack-loading/src/main/java/net/minestom/vanilla/datapack/loot/LootTable.java b/datapack-loading/src/main/java/net/minestom/vanilla/datapack/loot/LootTable.java
@@ -44,6 +44,7 @@ static Pool.Entry fromJson(JsonReader reader) throws IOException {
                     case "minecraft:tag" -> Pool.Entry.Tag.class;
                     case "minecraft:loot_table" -> Pool.Entry.LootTableNested.class;
                     case "minecraft:dynamic" -> Pool.Entry.Dynamic.class;
+                    case "minecraft:slots" -> Pool.Entry.Slots.class;
                     case "minecraft:empty" -> Pool.Entry.Empty.class;
                     case "minecraft:group" -> Pool.Entry.Group.class;
                     case "minecraft:alternatives" -> Pool.Entry.Alternatives.class;
@@ -183,6 +184,28 @@ public List<List<ItemStack>> apply(Datapack datapack, LootContext context) {
                 }
             }
 
+            /**
+             * slots -> Provides the items contained within slots selected by a slot source.
+             * • slot_source: A slot source describing where the items are located.
+             */
+            record Slots(List<Predicate> conditions,
+                         List<LootFunction> functions,
+                         NumberProvider weight,
+                         NumberProvider quality,
+                         SlotSource slot_source) implements ItemGenerator {
+
+                @Override
+                public Key type() {
+                    return Key.key("minecraft:slots");
+                }
+
+                @Override
+                public List<List<ItemStack>> apply(Datapack datapack, LootContext context) {
+                    // TODO: Resolve slot_source against loot context and produce items.
+                    return List.of(List.of());
+                }
+            }
+
             /**
              * empty -> Provides a loot entry that generates nothing into the loot pool.
              * • functions: Invokes item functions to the item stack(s).

diff --git a/datapack-loading/src/main/java/net/minestom/vanilla/datapack/loot/SlotSource.java b/datapack-loading/src/main/java/net/minestom/vanilla/datapack/loot/SlotSource.java
@@ -0,0 +1,56 @@
+package net.minestom.vanilla.datapack.loot;
+
+import com.squareup.moshi.JsonReader;
+import net.kyori.adventure.key.Key;
+import net.minestom.vanilla.datapack.json.JsonUtils;
+import net.minestom.vanilla.datapack.tags.ConditionsFor;
+
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * Slot source definitions introduced in datapack version 92.0.
+ */
+public sealed interface SlotSource {
+    static SlotSource fromJson(JsonReader reader) throws IOException {
+        return JsonUtils.typeMap(reader, token -> switch (token) {
+            case BEGIN_ARRAY -> json -> {
+                json.beginArray();
+                java.util.ArrayList<SlotSource> terms = new java.util.ArrayList<>();
+                while (json.hasNext()) {
+                    terms.add(fromJson(json));
+                }
+                json.endArray();
+                return new Group(List.copyOf(terms));
+            };
+            case BEGIN_OBJECT -> json -> JsonUtils.unionStringTypeAdapted(json, "type", type -> switch (type) {
+                case "minecraft:empty" -> Empty.class;
+                case "minecraft:group" -> Group.class;
+                case "minecraft:slot_range" -> SlotRange.class;
+                case "minecraft:contents" -> Contents.class;
+                case "minecraft:filtered" -> Filtered.class;
+                case "minecraft:limit_slots" -> LimitSlots.class;
+                default -> null;
+            });
+            default -> null;
+        });
+    }
+
+    record Empty() implements SlotSource {
+    }
+
+    record Group(List<SlotSource> terms) implements SlotSource {
+    }
+
+    record SlotRange(String source, String slots) implements SlotSource {
+    }
+
+    record Contents(Key component, SlotSource slot_source) implements SlotSource {
+    }
+
+    record Filtered(ConditionsFor.Item item_filter, SlotSource slot_source) implements SlotSource {
+    }
+
+    record LimitSlots(int limit, SlotSource slot_source) implements SlotSource {
+    }
+}