fix: Select a correct Y in 'server' spawn mode, fallback on default spawnLocation if none available

Author: Xephi

authme-core/src/main/java/fr/xephi/authme/settings/SpawnLoader.java

@@ -14,6 +14,7 @@
 import org.bukkit.GameRule;
 import org.bukkit.Location;
 import org.bukkit.World;
+import org.bukkit.block.Block;
 import org.bukkit.configuration.file.FileConfiguration;
 import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.entity.Player;
@@ -262,8 +263,48 @@ private Location getServerSpawnLocation(World world) {
         int dz = (int) (Math.random() * (radius * 2 + 1)) - radius;
         int x = (int) worldSpawn.getX() + dx;
         int z = (int) worldSpawn.getZ() + dz;
-        int y = world.getHighestBlockYAt(x, z) + 1;
-        return new Location(world, x + 0.5, y, z + 0.5, worldSpawn.getYaw(), worldSpawn.getPitch());
+        Integer y = getSafeSpawnY(world, x, z, worldSpawn.getBlockY());
+        if (y == null) {
+            return worldSpawn;
+        }
+        double spawnX = x + 0.5;
+        double spawnZ = z + 0.5;
+        float yaw = (float) Math.toDegrees(Math.atan2(-(worldSpawn.getX() - spawnX), worldSpawn.getZ() - spawnZ));
+        return new Location(world, spawnX, y, spawnZ, yaw, 0.0f);
+    }
+
+    /**
+     * Returns a safe Y coordinate for spawning at (x, z), searching near the world spawn's Y.
+     * Checks if the foot and head blocks are passable at the base Y; if the foot is already
+     * passable the search goes downward (looking for a floor), otherwise upward (looking for a gap).
+     * A margin of 10 blocks is applied in each direction. Returns {@code null} if no safe spot
+     * is found, in which case the caller should fall back to the exact world spawn location.
+     */
+    private Integer getSafeSpawnY(World world, int x, int z, int baseY) {
+        if (isPassable(world, x, baseY, z) && isPassable(world, x, baseY + 1, z)) {
+            return baseY;
+        }
+        int margin = 10;
+        if (world.getBlockAt(x, baseY, z).isPassable()) {
+            for (int dy = 1; dy <= margin; dy++) {
+                int y = baseY - dy;
+                if (isPassable(world, x, y, z) && isPassable(world, x, y + 1, z)) {
+                    return y;
+                }
+            }
+        } else {
+            for (int dy = 1; dy <= margin; dy++) {
+                int y = baseY + dy;
+                if (isPassable(world, x, y, z) && isPassable(world, x, y + 1, z)) {
+                    return y;
+                }
+            }
+        }
+        return null;
+    }
+
+    private boolean isPassable(World world, int x, int y, int z) {
+        return world.getBlockAt(x, y, z).isPassable();
     }
 
     /**

authme-core/src/test/java/fr/xephi/authme/settings/SpawnLoaderTest.java

@@ -13,7 +13,9 @@
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.World;
+import org.bukkit.block.Block;
 import org.bukkit.entity.Player;
+import org.mockito.ArgumentMatchers;
 import org.bukkit.configuration.file.YamlConfiguration;
 import org.junit.jupiter.api.Test;
 import fr.xephi.authme.TempFolder;
@@ -27,6 +29,7 @@
 import org.bukkit.GameRule;
 
 import static org.hamcrest.Matchers.both;
+import static org.hamcrest.Matchers.closeTo;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.greaterThanOrEqualTo;
 import static org.hamcrest.Matchers.lessThanOrEqualTo;
@@ -147,24 +150,127 @@ public void shouldReturnExactWorldSpawnForServerPriorityWithZeroRadius() {
     }
 
     @Test
-    public void shouldReturnLocationWithinRadiusForServerPriority() {
+    public void shouldReturnExactYAndFaceTowardCenterWhenBaseYIsAlreadySafe() {
         // given
         given(settings.getProperty(RestrictionSettings.SPAWN_PRIORITY)).willReturn("server");
         spawnLoader.reload();
 
         World world = mock(World.class);
+        // worldSpawn at (100, 64, 200); place the result due east (+X) so the expected yaw is -90°
         Location worldSpawn = new Location(world, 100.0, 64.0, 200.0);
         given(world.getSpawnLocation()).willReturn(worldSpawn);
+        // radius=0 forces dx=dz=0 → exact worldSpawn → returned as-is (no yaw recalculation)
         given(world.getGameRuleValue(GameRule.SPAWN_RADIUS)).willReturn(10);
-        given(world.getHighestBlockYAt(org.mockito.ArgumentMatchers.anyInt(), org.mockito.ArgumentMatchers.anyInt())).willReturn(63);
+
+        Block passable = mock(Block.class);
+        given(passable.isPassable()).willReturn(true);
+        given(world.getBlockAt(ArgumentMatchers.anyInt(), ArgumentMatchers.eq(64), ArgumentMatchers.anyInt()))
+            .willReturn(passable);
+        given(world.getBlockAt(ArgumentMatchers.anyInt(), ArgumentMatchers.eq(65), ArgumentMatchers.anyInt()))
+            .willReturn(passable);
 
         // when
         Location result = spawnLoader.getSpawnLocation(world);
 
-        // then
+        // then – position within radius, Y unchanged, pitch = 0
         assertThat(result.getX(), both(greaterThanOrEqualTo(90.5)).and(lessThanOrEqualTo(110.5)));
         assertThat(result.getZ(), both(greaterThanOrEqualTo(190.5)).and(lessThanOrEqualTo(210.5)));
-        assertThat(result.getY(), equalTo(64.0)); // highestBlockYAt(63) + 1 = 64
+        assertThat(result.getY(), equalTo(64.0));
+        assertThat((double) result.getPitch(), closeTo(0.0, 0.001));
+        // yaw must point from the result position toward worldSpawn (100, 200)
+        double expectedYaw = Math.toDegrees(Math.atan2(-(100.0 - result.getX()), 200.0 - result.getZ()));
+        assertThat((double) result.getYaw(), closeTo(expectedYaw, 0.001));
+    }
+
+    @Test
+    public void shouldSearchDownwardWhenBaseYIsInAVoid() {
+        // given – foot at baseY is passable but head (baseY+1) is solid (1-block-high gap, e.g. near Nether ceiling)
+        given(settings.getProperty(RestrictionSettings.SPAWN_PRIORITY)).willReturn("server");
+        spawnLoader.reload();
+
+        World world = mock(World.class);
+        Location worldSpawn = new Location(world, 0.0, 70.0, 0.0);
+        given(world.getSpawnLocation()).willReturn(worldSpawn);
+        given(world.getGameRuleValue(GameRule.SPAWN_RADIUS)).willReturn(5);
+
+        Block passable = mock(Block.class);
+        given(passable.isPassable()).willReturn(true);
+        Block solid = mock(Block.class);
+        given(solid.isPassable()).willReturn(false);
+
+        // y=70 passable, y=71 solid → initial check fails; foot is passable → search downward
+        given(world.getBlockAt(ArgumentMatchers.anyInt(), ArgumentMatchers.eq(70), ArgumentMatchers.anyInt()))
+            .willReturn(passable);
+        given(world.getBlockAt(ArgumentMatchers.anyInt(), ArgumentMatchers.eq(71), ArgumentMatchers.anyInt()))
+            .willReturn(solid);
+        // y=69 passable → isPassable(69) && isPassable(70) = true → safe at y=69
+        given(world.getBlockAt(ArgumentMatchers.anyInt(), ArgumentMatchers.eq(69), ArgumentMatchers.anyInt()))
+            .willReturn(passable);
+
+        // when
+        Location result = spawnLoader.getSpawnLocation(world);
+
+        // then – first clear 2-block gap found going downward is at y=69
+        assertThat(result.getY(), equalTo(69.0));
+    }
+
+    @Test
+    public void shouldSearchUpwardWhenBaseYIsInsideASolidBlock() {
+        // given – baseY is inside a solid block (e.g. underground)
+        given(settings.getProperty(RestrictionSettings.SPAWN_PRIORITY)).willReturn("server");
+        spawnLoader.reload();
+
+        World world = mock(World.class);
+        Location worldSpawn = new Location(world, 0.0, 60.0, 0.0);
+        given(world.getSpawnLocation()).willReturn(worldSpawn);
+        given(world.getGameRuleValue(GameRule.SPAWN_RADIUS)).willReturn(5);
+
+        Block passable = mock(Block.class);
+        given(passable.isPassable()).willReturn(true);
+        Block solid = mock(Block.class);
+        given(solid.isPassable()).willReturn(false);
+
+        // y=60 is solid → search upward
+        given(world.getBlockAt(ArgumentMatchers.anyInt(), ArgumentMatchers.eq(60), ArgumentMatchers.anyInt()))
+            .willReturn(solid);
+        // y=61 solid, y=62 solid, y=63 passable, y=64 passable → safe at y=63
+        given(world.getBlockAt(ArgumentMatchers.anyInt(), ArgumentMatchers.eq(61), ArgumentMatchers.anyInt()))
+            .willReturn(solid);
+        given(world.getBlockAt(ArgumentMatchers.anyInt(), ArgumentMatchers.eq(62), ArgumentMatchers.anyInt()))
+            .willReturn(solid);
+        given(world.getBlockAt(ArgumentMatchers.anyInt(), ArgumentMatchers.eq(63), ArgumentMatchers.anyInt()))
+            .willReturn(passable);
+        given(world.getBlockAt(ArgumentMatchers.anyInt(), ArgumentMatchers.eq(64), ArgumentMatchers.anyInt()))
+            .willReturn(passable);
+
+        // when
+        Location result = spawnLoader.getSpawnLocation(world);
+
+        // then
+        assertThat(result.getY(), equalTo(63.0));
+    }
+
+    @Test
+    public void shouldFallbackToExactWorldSpawnWhenNoSafeSpotFoundWithinMargin() {
+        // given
+        given(settings.getProperty(RestrictionSettings.SPAWN_PRIORITY)).willReturn("server");
+        spawnLoader.reload();
+
+        World world = mock(World.class);
+        Location worldSpawn = new Location(world, 12.0, 64.0, -34.0);
+        given(world.getSpawnLocation()).willReturn(worldSpawn);
+        given(world.getGameRuleValue(GameRule.SPAWN_RADIUS)).willReturn(5);
+
+        Block solid = mock(Block.class);
+        given(solid.isPassable()).willReturn(false);
+        given(world.getBlockAt(ArgumentMatchers.anyInt(), ArgumentMatchers.anyInt(), ArgumentMatchers.anyInt()))
+            .willReturn(solid);
+
+        // when
+        Location result = spawnLoader.getSpawnLocation(world);
+
+        // then – falls back to exact worldSpawn (X/Y/Z unchanged)
+        assertThat(result, equalTo(worldSpawn));
     }
 
     @Test