Pull upstream

jcstress-tests/src/jcstress/java/net/minestom/server/tag/TagPathOverrideTest.java

@@ -1,11 +1,12 @@
 package net.minestom.server.tag;
 
-import org.jglrxavpok.hephaistos.nbt.NBT;
+import net.kyori.adventure.nbt.CompoundBinaryTag;
 import org.openjdk.jcstress.annotations.*;
 import org.openjdk.jcstress.infra.results.L_Result;
 
 import java.util.Map;
 
+import static net.kyori.adventure.nbt.IntBinaryTag.intBinaryTag;
 import static org.openjdk.jcstress.annotations.Expect.ACCEPTABLE;
 
 @JCStressTest
@@ -30,9 +31,9 @@ public void actor2() {
     @Arbiter
     public void arbiter(L_Result r) {
         var compound = handler.asCompound();
-        if (compound.equals(NBT.Compound(Map.of("path", NBT.Compound(Map.of("key", NBT.Int(1))))))) {
+        if (compound.equals(CompoundBinaryTag.from(Map.of("path", CompoundBinaryTag.from(Map.of("key", intBinaryTag(1))))))) {
             r.r1 = "actor1";
-        } else if (compound.equals(NBT.Compound(Map.of("path", NBT.Compound(Map.of("key", NBT.Int(5))))))) {
+        } else if (compound.equals(CompoundBinaryTag.from(Map.of("path", CompoundBinaryTag.from(Map.of("key", intBinaryTag(5))))))) {
             r.r1 = "actor2";
         } else {
             r.r1 = compound;

jcstress-tests/src/jcstress/java/net/minestom/server/tag/TagPathTest.java

@@ -1,11 +1,12 @@
 package net.minestom.server.tag;
 
-import org.jglrxavpok.hephaistos.nbt.NBT;
+import net.kyori.adventure.nbt.CompoundBinaryTag;
 import org.openjdk.jcstress.annotations.*;
 import org.openjdk.jcstress.infra.results.L_Result;
 
 import java.util.Map;
 
+import static net.kyori.adventure.nbt.IntBinaryTag.intBinaryTag;
 import static org.openjdk.jcstress.annotations.Expect.ACCEPTABLE;
 
 @JCStressTest
@@ -31,9 +32,9 @@ public void actor2() {
     @Arbiter
     public void arbiter(L_Result r) {
         var compound = handler.asCompound();
-        if (compound.equals(NBT.Compound(Map.of("path", NBT.Int(1))))) {
+        if (compound.equals(CompoundBinaryTag.from(Map.of("path", intBinaryTag(1))))) {
             r.r1 = "tag";
-        } else if (compound.equals(NBT.Compound(Map.of("path", NBT.Compound(Map.of("key", NBT.Int(5))))))) {
+        } else if (compound.equals(CompoundBinaryTag.from(Map.of("path", CompoundBinaryTag.from(Map.of("key", intBinaryTag(5))))))) {
             r.r1 = "tag_path";
         } else {
             r.r1 = compound;

jmh-benchmarks/src/jmh/java/net/minestom/server/tag/TagReadBenchmark.java

@@ -1,11 +1,10 @@
 package net.minestom.server.tag;
 
-import org.jglrxavpok.hephaistos.nbt.NBT;
-import org.jglrxavpok.hephaistos.nbt.mutable.MutableNBTCompound;
 import org.openjdk.jmh.annotations.*;
 import org.openjdk.jmh.infra.Blackhole;
 
 import java.util.HashMap;
+import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.TimeUnit;
 
@@ -24,8 +23,8 @@ public class TagReadBenchmark {
     TagHandler tagHandler;
     Tag<String> secondTag;
 
-    MutableNBTCompound concurrentCompound;
-    MutableNBTCompound compound;
+    Map<String, String> map;
+    Map<String, String> concurrentMap;
 
     @Setup
     public void setup() {
@@ -34,11 +33,11 @@ public void setup() {
         if (present) tagHandler.setTag(TAG, "value");
         secondTag = Tag.String("key");
         // Concurrent map benchmark
-        this.concurrentCompound = new MutableNBTCompound(new ConcurrentHashMap<>());
-        if (present) concurrentCompound.set("key", NBT.String("value"));
+        map = new HashMap<>();
+        if (present) map.put("key", "value");
         // Hash map benchmark
-        this.compound = new MutableNBTCompound(new HashMap<>());
-        if (present) compound.set("key", NBT.String("value"));
+        concurrentMap = new ConcurrentHashMap<>();
+        if (present) concurrentMap.put("key", "value");
     }
 
     @Benchmark
@@ -57,12 +56,12 @@ public void readNewTag(Blackhole blackhole) {
     }
 
     @Benchmark
-    public void readConcurrentCompound(Blackhole blackhole) {
-        blackhole.consume(concurrentCompound.getString("key"));
+    public void readConcurrentMap(Blackhole blackhole) {
+        blackhole.consume(concurrentMap.get("key"));
     }
 
     @Benchmark
-    public void readCompound(Blackhole blackhole) {
-        blackhole.consume(compound.getString("key"));
+    public void readMap(Blackhole blackhole) {
+        blackhole.consume(map.get("key"));
     }
 }

jmh-benchmarks/src/jmh/java/net/minestom/server/tag/TagWriteBenchmark.java

@@ -1,10 +1,9 @@
 package net.minestom.server.tag;
 
-import org.jglrxavpok.hephaistos.nbt.NBT;
-import org.jglrxavpok.hephaistos.nbt.mutable.MutableNBTCompound;
 import org.openjdk.jmh.annotations.*;
 
 import java.util.HashMap;
+import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.TimeUnit;
 
@@ -20,8 +19,8 @@ public class TagWriteBenchmark {
     TagHandler tagHandler;
     Tag<String> secondTag;
 
-    MutableNBTCompound concurrentCompound;
-    MutableNBTCompound compound;
+    Map<String, String> map;
+    Map<String, String> concurrentMap;
 
     @Setup
     public void setup() {
@@ -30,11 +29,11 @@ public void setup() {
         tagHandler.setTag(TAG, "value");
         secondTag = Tag.String("key");
         // Concurrent map benchmark
-        this.concurrentCompound = new MutableNBTCompound(new ConcurrentHashMap<>());
-        concurrentCompound.set("key", NBT.String("value"));
+        map = new HashMap<>();
+        map.put("key", "value");
         // Hash map benchmark
-        this.compound = new MutableNBTCompound(new HashMap<>());
-        compound.set("key", NBT.String("value"));
+        concurrentMap = new ConcurrentHashMap<>();
+        concurrentMap.put("key", "value");
     }
 
     @Benchmark
@@ -53,12 +52,12 @@ public void writeNewTag() {
     }
 
     @Benchmark
-    public void writeConcurrentCompound() {
-        concurrentCompound.setString("key", "value");
+    public void writeConcurrentMap() {
+        concurrentMap.put("key", "value");
     }
 
     @Benchmark
-    public void writeCompound() {
-        compound.setString("key", "value");
+    public void writeMap() {
+        map.put("key", "value");
     }
 }

src/main/java/net/minestom/server/collision/BlockCollision.java

@@ -4,10 +4,7 @@
 import net.minestom.server.coordinate.Pos;
 import net.minestom.server.coordinate.Vec;
 import net.minestom.server.entity.Entity;
-import net.minestom.server.entity.EntityType;
-import net.minestom.server.entity.GameMode;
 import net.minestom.server.entity.Player;
-import net.minestom.server.entity.metadata.other.ArmorStandMeta;
 import net.minestom.server.instance.Instance;
 import net.minestom.server.instance.block.Block;
 import net.minestom.server.utils.block.BlockIterator;
@@ -29,7 +26,7 @@ static PhysicsResult handlePhysics(@NotNull BoundingBox boundingBox,
         if (velocity.isZero()) {
             // TODO should return a constant
             return new PhysicsResult(entityPosition, Vec.ZERO, false, false, false, false,
-                    velocity, new Point[3], new Shape[3], false, SweepResult.NO_COLLISION);
+                    velocity, new Point[3], new Shape[3], new Point[3], false, SweepResult.NO_COLLISION);
         }
         // Fast-exit using cache
         final PhysicsResult cachedResult = cachedPhysics(velocity, entityPosition, getter, lastPhysicsResult);
@@ -42,18 +39,11 @@ static PhysicsResult handlePhysics(@NotNull BoundingBox boundingBox,
 
     static Entity canPlaceBlockAt(Instance instance, Point blockPos, Block b) {
         for (Entity entity : instance.getNearbyEntities(blockPos, 3)) {
-            final EntityType type = entity.getEntityType();
-            if (!entity.hasCollision() || type == EntityType.ITEM || type == EntityType.ARROW)
-                continue;
-            // Marker Armor Stands should not prevent block placement
-            if (entity.getEntityMeta() instanceof ArmorStandMeta armorStandMeta && armorStandMeta.isMarker())
+            if (!entity.preventBlockPlacement())
                 continue;
 
             final boolean intersects;
             if (entity instanceof Player) {
-                // Ignore spectators
-                if (((Player) entity).getGameMode() == GameMode.SPECTATOR)
-                    continue;
                 // Need to move player slightly away from block we're placing.
                 // If player is at block 40 we cannot place a block at block 39 with side length 1 because the block will be in [39, 40]
                 // For this reason we subtract a small amount from the player position
@@ -70,16 +60,18 @@ static Entity canPlaceBlockAt(Instance instance, Point blockPos, Block b) {
     private static PhysicsResult cachedPhysics(Vec velocity, Pos entityPosition,
                                                Block.Getter getter, PhysicsResult lastPhysicsResult) {
         if (lastPhysicsResult != null && lastPhysicsResult.collisionShapes()[1] instanceof ShapeImpl shape) {
-            Block collisionBlockY = shape.block();
+            var currentBlock = getter.getBlock(lastPhysicsResult.collisionPoints()[1].sub(0, Vec.EPSILON, 0), Block.Getter.Condition.TYPE);
+            var lastBlockBoxes = shape.collisionBoundingBoxes();
+            var currentBlockBoxes = ((ShapeImpl) currentBlock.registry().collisionShape()).collisionBoundingBoxes();
 
             // Fast exit if entity hasn't moved
             if (lastPhysicsResult.collisionY()
                     && velocity.y() == lastPhysicsResult.originalDelta().y()
                     // Check block below to fast exit gravity
-                    && getter.getBlock(lastPhysicsResult.collisionPoints()[1].sub(0, Vec.EPSILON, 0), Block.Getter.Condition.TYPE) == collisionBlockY
+                    && currentBlockBoxes.equals(lastBlockBoxes)
                     && velocity.x() == 0 && velocity.z() == 0
                     && entityPosition.samePoint(lastPhysicsResult.newPosition())
-                    && collisionBlockY != Block.AIR) {
+                    && !lastBlockBoxes.isEmpty()) {
                 return lastPhysicsResult;
             }
         }
@@ -90,12 +82,13 @@ private static PhysicsResult stepPhysics(@NotNull BoundingBox boundingBox,
                                              @NotNull Vec velocity, @NotNull Pos entityPosition,
                                              @NotNull Block.Getter getter, boolean singleCollision) {
         // Allocate once and update values
-        SweepResult finalResult = new SweepResult(1 - Vec.EPSILON, 0, 0, 0, null, 0, 0, 0);
+        SweepResult finalResult = new SweepResult(1 - Vec.EPSILON, 0, 0, 0, null, 0, 0, 0, 0, 0, 0);
 
         boolean foundCollisionX = false, foundCollisionY = false, foundCollisionZ = false;
 
         Point[] collidedPoints = new Point[3];
         Shape[] collisionShapes = new Shape[3];
+        Point[] collisionShapePositions = new Point[3];
 
         boolean hasCollided = false;
 
@@ -114,18 +107,21 @@ private static PhysicsResult stepPhysics(@NotNull BoundingBox boundingBox,
             if (result.collisionX()) {
                 foundCollisionX = true;
                 collisionShapes[0] = finalResult.collidedShape;
+                collisionShapePositions[0] = new Vec(finalResult.collidedShapeX, finalResult.collidedShapeY, finalResult.collidedShapeZ);
                 collidedPoints[0] = new Vec(finalResult.collidedPositionX, finalResult.collidedPositionY, finalResult.collidedPositionZ);
                 hasCollided = true;
                 if (singleCollision) break;
             } else if (result.collisionZ()) {
                 foundCollisionZ = true;
                 collisionShapes[2] = finalResult.collidedShape;
+                collisionShapePositions[2] = new Vec(finalResult.collidedShapeX, finalResult.collidedShapeY, finalResult.collidedShapeZ);
                 collidedPoints[2] = new Vec(finalResult.collidedPositionX, finalResult.collidedPositionY, finalResult.collidedPositionZ);
                 hasCollided = true;
                 if (singleCollision) break;
             } else if (result.collisionY()) {
                 foundCollisionY = true;
                 collisionShapes[1] = finalResult.collidedShape;
+                collisionShapePositions[1] = new Vec(finalResult.collidedShapeX, finalResult.collidedShapeY, finalResult.collidedShapeZ);
                 collidedPoints[1] = new Vec(finalResult.collidedPositionX, finalResult.collidedPositionY, finalResult.collidedPositionZ);
                 hasCollided = true;
                 if (singleCollision) break;
@@ -148,7 +144,7 @@ private static PhysicsResult stepPhysics(@NotNull BoundingBox boundingBox,
 
         return new PhysicsResult(result.newPosition(), new Vec(newDeltaX, newDeltaY, newDeltaZ),
                 newDeltaY == 0 && velocity.y() < 0,
-                foundCollisionX, foundCollisionY, foundCollisionZ, velocity, collidedPoints, collisionShapes, hasCollided, finalResult);
+                foundCollisionX, foundCollisionY, foundCollisionZ, velocity, collidedPoints, collisionShapes, collisionShapePositions, hasCollided, finalResult);
     }
 
     private static PhysicsResult computePhysics(@NotNull BoundingBox boundingBox,
@@ -185,7 +181,7 @@ private static PhysicsResult computePhysics(@NotNull BoundingBox boundingBox,
 
         return new PhysicsResult(finalPos, new Vec(remainingX, remainingY, remainingZ),
                 collisionY, collisionX, collisionY, collisionZ,
-                Vec.ZERO, null, null, false, finalResult);
+                Vec.ZERO, null, null, null, false, finalResult);
     }
 
     private static boolean isDiagonal(Vec velocity) {