Add Tickable interface (#1790)

* Add Tickable interface

By having a tickable interface, we're only dedicating one thread to ticking entities and running tasks as opposed to several. This will also help with implementing world border support.

* removeEntity already clears tickableEntities for us

* Only tick the entity if it's not being ticked

connector/src/main/java/org/geysermc/connector/entity/ItemedFireballEntity.java

@@ -38,11 +38,11 @@ public class ItemedFireballEntity extends ThrowableEntity {
     }
 
     @Override
-    protected void updatePosition(GeyserSession session) {
+    public void tick(GeyserSession session) {
         position = position.add(motion);
         // TODO: While this reduces latency in position updating (needed for better fireball reflecting),
-        // TODO: movement is incredibly stiff. See if the MoveEntityDeltaPacket in 1.16.100 fixes this, and if not,
-        // TODO: only use this laggy movement for fireballs that be reflected
+        // TODO: movement is incredibly stiff.
+        // TODO: Only use this laggy movement for fireballs that be reflected
         moveAbsoluteImmediate(session, position, rotation, false, true);
         float drag = getDrag(session);
         motion = motion.add(acceleration).mul(drag);

connector/src/main/java/org/geysermc/connector/entity/ThrowableEntity.java

@@ -33,50 +33,35 @@ import org.geysermc.connector.entity.type.EntityType;
 import org.geysermc.connector.network.session.GeyserSession;
 import org.geysermc.connector.network.translators.world.block.BlockTranslator;
 
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.TimeUnit;
-
 /**
  * Used as a class for any object-like entity that moves as a projectile
  */
-public class ThrowableEntity extends Entity {
+public class ThrowableEntity extends Entity implements Tickable {
 
     private Vector3f lastPosition;
-    /**
-     * Updates the position for the Bedrock client.
-     *
-     * Java clients assume the next positions of moving items. Bedrock needs to be explicitly told positions
-     */
-    protected ScheduledFuture<?> positionUpdater;
 
     public ThrowableEntity(long entityId, long geyserId, EntityType entityType, Vector3f position, Vector3f motion, Vector3f rotation) {
         super(entityId, geyserId, entityType, position, motion, rotation);
         this.lastPosition = position;
     }
 
+    /**
+     * Updates the position for the Bedrock client.
+     *
+     * Java clients assume the next positions of moving items. Bedrock needs to be explicitly told positions
+     */
     @Override
-    public void spawnEntity(GeyserSession session) {
-        super.spawnEntity(session);
-        positionUpdater = session.getConnector().getGeneralThreadPool().scheduleAtFixedRate(() -> {
-            if (session.isClosed()) {
-                positionUpdater.cancel(true);
-                return;
-            }
-            updatePosition(session);
-        }, 0, 50, TimeUnit.MILLISECONDS);
-    }
-
-    protected void moveAbsoluteImmediate(GeyserSession session, Vector3f position, Vector3f rotation, boolean isOnGround, boolean teleported) {
-        super.moveAbsolute(session, position, rotation, isOnGround, teleported);
-    }
-
-    protected void updatePosition(GeyserSession session) {
+    public void tick(GeyserSession session) {
         super.moveRelative(session, motion.getX(), motion.getY(), motion.getZ(), rotation, onGround);
         float drag = getDrag(session);
         float gravity = getGravity();
         motion = motion.mul(drag).down(gravity);
     }
 
+    protected void moveAbsoluteImmediate(GeyserSession session, Vector3f position, Vector3f rotation, boolean isOnGround, boolean teleported) {
+        super.moveAbsolute(session, position, rotation, isOnGround, teleported);
+    }
+
     /**
      * Get the gravity of this entity type. Used for applying gravity while the entity is in motion.
      *
@@ -140,7 +125,6 @@ public class ThrowableEntity extends Entity {
 
     @Override
     public boolean despawnEntity(GeyserSession session) {
-        positionUpdater.cancel(true);
         if (entityType == EntityType.THROWN_ENDERPEARL) {
             LevelEventPacket particlePacket = new LevelEventPacket();
             particlePacket.setType(LevelEventType.PARTICLE_TELEPORT);

connector/src/main/java/org/geysermc/connector/entity/Tickable.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2019-2021 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Geyser
+ */
+
+package org.geysermc.connector.entity;
+
+import org.geysermc.connector.network.session.GeyserSession;
+
+/**
+ * Implemented onto anything that should have code ran every Minecraft tick - 50 milliseconds.
+ */
+public interface Tickable {
+    void tick(GeyserSession session);
+}

connector/src/main/java/org/geysermc/connector/entity/living/monster/EnderDragonEntity.java

@@ -33,14 +33,12 @@ import com.nukkitx.protocol.bedrock.data.entity.EntityFlag;
 import com.nukkitx.protocol.bedrock.packet.AddEntityPacket;
 import com.nukkitx.protocol.bedrock.packet.EntityEventPacket;
 import lombok.Data;
+import org.geysermc.connector.entity.Tickable;
 import org.geysermc.connector.entity.living.InsentientEntity;
 import org.geysermc.connector.entity.type.EntityType;
 import org.geysermc.connector.network.session.GeyserSession;
 
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.TimeUnit;
-
-public class EnderDragonEntity extends InsentientEntity {
+public class EnderDragonEntity extends InsentientEntity implements Tickable {
     /**
      * The Ender Dragon has multiple hit boxes, which
      * are each its own invisible entity
@@ -63,8 +61,6 @@ public class EnderDragonEntity extends InsentientEntity {
 
     private boolean hovering;
 
-    private ScheduledFuture<?> partPositionUpdater;
-
     public EnderDragonEntity(long entityId, long geyserId, EntityType entityType, Vector3f position, Vector3f motion, Vector3f rotation) {
         super(entityId, geyserId, entityType, position, motion, rotation);
 
@@ -130,24 +126,23 @@ public class EnderDragonEntity extends InsentientEntity {
             segmentHistory[i].y = position.getY();
         }
 
-        partPositionUpdater = session.getConnector().getGeneralThreadPool().scheduleAtFixedRate(() -> {
-            pushSegment();
-            updateBoundingBoxes(session);
-        }, 0, 50, TimeUnit.MILLISECONDS);
-
         session.getConnector().getLogger().debug("Spawned entity " + entityType + " at location " + position + " with id " + geyserId + " (java id " + entityId + ")");
     }
 
     @Override
     public boolean despawnEntity(GeyserSession session) {
-        partPositionUpdater.cancel(true);
-
         for (EnderDragonPartEntity part : allParts) {
             part.despawnEntity(session);
         }
         return super.despawnEntity(session);
     }
 
+    @Override
+    public void tick(GeyserSession session) {
+        pushSegment();
+        updateBoundingBoxes(session);
+    }
+
     /**
      * Updates the positions of the Ender Dragon's multiple bounding boxes
      *

connector/src/main/java/org/geysermc/connector/network/session/GeyserSession.java

@@ -35,6 +35,7 @@ import com.github.steveice10.mc.protocol.data.game.entity.player.GameMode;
 import com.github.steveice10.mc.protocol.data.game.statistic.Statistic;
 import com.github.steveice10.mc.protocol.data.game.window.VillagerTrade;
 import com.github.steveice10.mc.protocol.packet.handshake.client.HandshakePacket;
+import com.github.steveice10.mc.protocol.packet.ingame.client.player.ClientPlayerPositionPacket;
 import com.github.steveice10.mc.protocol.packet.ingame.client.player.ClientPlayerPositionRotationPacket;
 import com.github.steveice10.mc.protocol.packet.ingame.client.world.ClientTeleportConfirmPacket;
 import com.github.steveice10.mc.protocol.packet.login.server.LoginSuccessPacket;
@@ -64,6 +65,7 @@ import lombok.Setter;
 import org.geysermc.common.window.CustomFormWindow;
 import org.geysermc.common.window.FormWindow;
 import org.geysermc.connector.GeyserConnector;
+import org.geysermc.connector.entity.Tickable;
 import org.geysermc.connector.command.CommandSender;
 import org.geysermc.connector.common.AuthType;
 import org.geysermc.connector.entity.Entity;
@@ -94,6 +96,7 @@ import java.security.spec.InvalidKeySpecException;
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
 
 @Getter
 public class GeyserSession implements CommandSender {
@@ -245,10 +248,10 @@ public class GeyserSession implements CommandSender {
     private ScheduledFuture<?> bucketScheduledFuture;
 
     /**
-     * Sends a movement packet every three seconds if the player hasn't moved. Prevents timeouts when AFK in certain instances.
+     * Used to send a movement packet every three seconds if the player hasn't moved. Prevents timeouts when AFK in certain instances.
      */
     @Setter
-    private ScheduledFuture<?> movementSendIfIdle;
+    private long lastMovementTimestamp = System.currentTimeMillis();
 
     /**
      * Controls whether the daylight cycle gamerule has been sent to the client, so the sun/moon remain motionless.
@@ -328,6 +331,11 @@ public class GeyserSession implements CommandSender {
     private List<UUID> selectedEmotes = new ArrayList<>();
     private final Set<UUID> emotes = new HashSet<>();
 
+    /**
+     * The thread that will run every 50 milliseconds - one Minecraft tick.
+     */
+    private ScheduledFuture<?> tickThread = null;
+
     private MinecraftProtocol protocol;
 
     public GeyserSession(GeyserConnector connector, BedrockServerSession bedrockServerSession) {
@@ -458,6 +466,9 @@ public class GeyserSession implements CommandSender {
                     connector.getLogger().info(LanguageUtils.getLocaleStringLog("geyser.auth.floodgate.loaded_key"));
                 }
 
+                // Start ticking
+                tickThread = connector.getGeneralThreadPool().scheduleAtFixedRate(this::tick, 50, 50, TimeUnit.MILLISECONDS);
+
                 downstream = new Client(remoteServer.getAddress(), remoteServer.getPort(), protocol, new TcpSessionFactory());
                 if (connector.getConfig().getRemote().isUseProxyProtocol()) {
                     downstream.getSession().setFlag(BuiltinFlags.ENABLE_CLIENT_PROXY_PROTOCOL, true);
@@ -584,6 +595,8 @@ public class GeyserSession implements CommandSender {
             }
         }
 
+        tickThread.cancel(true);
+
         this.chunkCache = null;
         this.entityCache = null;
         this.effectCache = null;
@@ -598,6 +611,28 @@ public class GeyserSession implements CommandSender {
         disconnect(LanguageUtils.getPlayerLocaleString("geyser.network.close", getClientData().getLanguageCode()));
     }
 
+    /**
+     * Called every 50 milliseconds - one Minecraft tick.
+     */
+    public void tick() {
+        // Check to see if the player's position needs updating - a position update should be sent once every 3 seconds
+        if (spawned && (System.currentTimeMillis() - lastMovementTimestamp) > 3000) {
+            // Recalculate in case something else changed position
+            Vector3d position = collisionManager.adjustBedrockPosition(playerEntity.getPosition(), playerEntity.isOnGround());
+            // A null return value cancels the packet
+            if (position != null) {
+                ClientPlayerPositionPacket packet = new ClientPlayerPositionPacket(playerEntity.isOnGround(),
+                        position.getX(), position.getY(), position.getZ());
+                sendDownstreamPacket(packet);
+            }
+            lastMovementTimestamp = System.currentTimeMillis();
+        }
+
+        for (Tickable entity : entityCache.getTickableEntities()) {
+            entity.tick(this);
+        }
+    }
+
     public void setAuthenticationData(AuthData authData) {
         this.authData = authData;
     }

connector/src/main/java/org/geysermc/connector/network/session/cache/EntityCache.java

@@ -28,6 +28,7 @@ package org.geysermc.connector.network.session.cache;
 import it.unimi.dsi.fastutil.longs.*;
 import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
 import lombok.Getter;
+import org.geysermc.connector.entity.Tickable;
 import org.geysermc.connector.entity.Entity;
 import org.geysermc.connector.entity.player.PlayerEntity;
 import org.geysermc.connector.network.session.GeyserSession;
@@ -40,17 +41,21 @@ import java.util.concurrent.atomic.AtomicLong;
  * for that player (e.g. seeing vanished players from /vanish)
  */
 public class EntityCache {
-    private GeyserSession session;
+    private final GeyserSession session;
 
     @Getter
     private Long2ObjectMap<Entity> entities = Long2ObjectMaps.synchronize(new Long2ObjectOpenHashMap<>());
+    /**
+     * A list of all entities that must be ticked.
+     */
+    private final List<Tickable> tickableEntities = Collections.synchronizedList(new ArrayList<>());
     private Long2LongMap entityIdTranslations = Long2LongMaps.synchronize(new Long2LongOpenHashMap());
     private Map<UUID, PlayerEntity> playerEntities = Collections.synchronizedMap(new HashMap<>());
     private Map<UUID, BossBar> bossBars = Collections.synchronizedMap(new HashMap<>());
-    private Long2LongMap cachedPlayerEntityLinks = Long2LongMaps.synchronize(new Long2LongOpenHashMap());
+    private final Long2LongMap cachedPlayerEntityLinks = Long2LongMaps.synchronize(new Long2LongOpenHashMap());
 
     @Getter
-    private AtomicLong nextEntityId = new AtomicLong(2L);
+    private final AtomicLong nextEntityId = new AtomicLong(2L);
 
     public EntityCache(GeyserSession session) {
         this.session = session;
@@ -59,6 +64,11 @@ public class EntityCache {
     public void spawnEntity(Entity entity) {
         if (cacheEntity(entity)) {
             entity.spawnEntity(session);
+
+            if (entity instanceof Tickable) {
+                // Start ticking it
+                tickableEntities.add((Tickable) entity);
+            }
         }
     }
 
@@ -76,6 +86,10 @@ public class EntityCache {
         if (entity != null && entity.isValid() && (force || entity.despawnEntity(session))) {
             long geyserId = entityIdTranslations.remove(entity.getEntityId());
             entities.remove(geyserId);
+
+            if (entity instanceof Tickable) {
+                tickableEntities.remove(entity);
+            }
             return true;
         }
         return false;
@@ -152,4 +166,8 @@ public class EntityCache {
     public void addCachedPlayerEntityLink(long playerId, long linkedEntityId) {
         cachedPlayerEntityLinks.put(playerId, linkedEntityId);
     }
+
+    public List<Tickable> getTickableEntities() {
+        return tickableEntities;
+    }
 }

connector/src/main/java/org/geysermc/connector/network/translators/bedrock/entity/player/BedrockMovePlayerTranslator.java

@@ -33,16 +33,12 @@ import com.nukkitx.math.vector.Vector3d;
 import com.nukkitx.math.vector.Vector3f;
 import com.nukkitx.protocol.bedrock.packet.MoveEntityAbsolutePacket;
 import com.nukkitx.protocol.bedrock.packet.MovePlayerPacket;
-import com.nukkitx.protocol.bedrock.packet.SetEntityDataPacket;
 import org.geysermc.connector.common.ChatColor;
 import org.geysermc.connector.entity.player.PlayerEntity;
 import org.geysermc.connector.entity.type.EntityType;
 import org.geysermc.connector.network.session.GeyserSession;
 import org.geysermc.connector.network.translators.PacketTranslator;
 import org.geysermc.connector.network.translators.Translator;
-import org.geysermc.connector.network.translators.collision.CollisionManager;
-
-import java.util.concurrent.TimeUnit;
 
 @Translator(packet = MovePlayerPacket.class)
 public class BedrockMovePlayerTranslator extends PacketTranslator<MovePlayerPacket> {
@@ -63,9 +59,7 @@ public class BedrockMovePlayerTranslator extends PacketTranslator<MovePlayerPack
             return;
         }
 
-        if (session.getMovementSendIfIdle() != null) {
-            session.getMovementSendIfIdle().cancel(true);
-        }
+        session.setLastMovementTimestamp(System.currentTimeMillis());
 
         if (session.confirmTeleport(packet.getPosition().toDouble().sub(0, EntityType.PLAYER.getOffset(), 0))) {
             // head yaw, pitch, head yaw
@@ -86,7 +80,7 @@ public class BedrockMovePlayerTranslator extends PacketTranslator<MovePlayerPack
 
                 session.sendDownstreamPacket(playerRotationPacket);
             } else {
-                Vector3d position = adjustBedrockPosition(session, packet.getPosition(), packet.isOnGround());
+                Vector3d position = session.getCollisionManager().adjustBedrockPosition(packet.getPosition(), packet.isOnGround());
                 if (position != null) { // A null return value cancels the packet
                     if (isValidMove(session, packet.getMode(), entity.getPosition(), packet.getPosition())) {
                         Packet movePacket;
@@ -128,7 +122,7 @@ public class BedrockMovePlayerTranslator extends PacketTranslator<MovePlayerPack
                     } else {
                         // Not a valid move
                         session.getConnector().getLogger().debug("Recalculating position...");
-                        recalculatePosition(session);
+                        session.getCollisionManager().recalculatePosition();
                     }
                 }
             }
@@ -141,13 +135,9 @@ public class BedrockMovePlayerTranslator extends PacketTranslator<MovePlayerPack
         if (entity.getRightParrot() != null) {
             entity.getRightParrot().moveAbsolute(session, entity.getPosition(), entity.getRotation(), true, false);
         }
-
-        // Schedule a position send loop if the player is idle
-        session.setMovementSendIfIdle(session.getConnector().getGeneralThreadPool().schedule(() -> sendPositionIfIdle(session),
-                3, TimeUnit.SECONDS));
     }
 
-    public boolean isValidMove(GeyserSession session, MovePlayerPacket.Mode mode, Vector3f currentPosition, Vector3f newPosition) {
+    private boolean isValidMove(GeyserSession session, MovePlayerPacket.Mode mode, Vector3f currentPosition, Vector3f newPosition) {
         if (mode != MovePlayerPacket.Mode.NORMAL)
             return true;
 
@@ -171,81 +161,5 @@ public class BedrockMovePlayerTranslator extends PacketTranslator<MovePlayerPack
 
         return true;
     }
-
-    /**
-     * Adjust the Bedrock position before sending to the Java server to account for inaccuracies in movement between
-     * the two versions.
-     *
-     * @param session the current GeyserSession
-     * @param bedrockPosition the current Bedrock position of the client
-     * @param onGround whether the Bedrock player is on the ground
-     * @return the position to send to the Java server, or null to cancel sending the packet
-     */
-    private Vector3d adjustBedrockPosition(GeyserSession session, Vector3f bedrockPosition, boolean onGround) {
-        // We need to parse the float as a string since casting a float to a double causes us to
-        // lose precision and thus, causes players to get stuck when walking near walls
-        double javaY = bedrockPosition.getY() - EntityType.PLAYER.getOffset();
-
-        Vector3d position = Vector3d.from(Double.parseDouble(Float.toString(bedrockPosition.getX())), javaY,
-                Double.parseDouble(Float.toString(bedrockPosition.getZ())));
-
-        if (session.getConnector().getConfig().isCacheChunks()) {
-            // With chunk caching, we can do some proper collision checks
-            CollisionManager collisionManager = session.getCollisionManager();
-            collisionManager.updatePlayerBoundingBox(position);
-
-            // Correct player position
-            if (!collisionManager.correctPlayerPosition()) {
-                // Cancel the movement if it needs to be cancelled
-                recalculatePosition(session);
-                return null;
-            }
-
-            position = Vector3d.from(collisionManager.getPlayerBoundingBox().getMiddleX(),
-                    collisionManager.getPlayerBoundingBox().getMiddleY() - (collisionManager.getPlayerBoundingBox().getSizeY() / 2),
-                    collisionManager.getPlayerBoundingBox().getMiddleZ());
-        } else {
-            // When chunk caching is off, we have to rely on this
-            // It rounds the Y position up to the nearest 0.5
-            // This snaps players to snap to the top of stairs and slabs like on Java Edition
-            // However, it causes issues such as the player floating on carpets
-            if (onGround) javaY = Math.ceil(javaY * 2) / 2;
-            position = position.up(javaY - position.getY());
-        }
-
-        return position;
-    }
-
-    // TODO: This makes the player look upwards for some reason, rotation values must be wrong
-    public void recalculatePosition(GeyserSession session) {
-        PlayerEntity entity = session.getPlayerEntity();
-        // Gravity might need to be reset...
-        SetEntityDataPacket entityDataPacket = new SetEntityDataPacket();
-        entityDataPacket.setRuntimeEntityId(entity.getGeyserId());
-        entityDataPacket.getMetadata().putAll(entity.getMetadata());
-        session.sendUpstreamPacket(entityDataPacket);
-
-        MovePlayerPacket movePlayerPacket = new MovePlayerPacket();
-        movePlayerPacket.setRuntimeEntityId(entity.getGeyserId());
-        movePlayerPacket.setPosition(entity.getPosition());
-        movePlayerPacket.setRotation(entity.getBedrockRotation());
-        movePlayerPacket.setMode(MovePlayerPacket.Mode.NORMAL);
-        session.sendUpstreamPacket(movePlayerPacket);
-    }
-
-    private void sendPositionIfIdle(GeyserSession session) {
-        if (session.isClosed()) return;
-        PlayerEntity entity = session.getPlayerEntity();
-        // Recalculate in case something else changed position
-        Vector3d position = adjustBedrockPosition(session, entity.getPosition(), entity.isOnGround());
-        // A null return value cancels the packet
-        if (position != null) {
-            ClientPlayerPositionPacket packet = new ClientPlayerPositionPacket(session.getPlayerEntity().isOnGround(),
-                    position.getX(), position.getY(), position.getZ());
-            session.sendDownstreamPacket(packet);
-        }
-        session.setMovementSendIfIdle(session.getConnector().getGeneralThreadPool().schedule(() -> sendPositionIfIdle(session),
-                3, TimeUnit.SECONDS));
-    }
 }
 

connector/src/main/java/org/geysermc/connector/network/translators/collision/CollisionManager.java

@@ -30,8 +30,12 @@ import com.nukkitx.math.vector.Vector3f;
 import com.nukkitx.math.vector.Vector3i;
 import com.nukkitx.protocol.bedrock.data.entity.EntityFlag;
 import com.nukkitx.protocol.bedrock.data.entity.EntityFlags;
+import com.nukkitx.protocol.bedrock.packet.MovePlayerPacket;
+import com.nukkitx.protocol.bedrock.packet.SetEntityDataPacket;
 import lombok.Getter;
 import lombok.Setter;
+import org.geysermc.connector.entity.player.PlayerEntity;
+import org.geysermc.connector.entity.type.EntityType;
 import org.geysermc.connector.network.session.GeyserSession;
 import org.geysermc.connector.network.translators.collision.translators.BlockCollision;
 
@@ -105,6 +109,7 @@ public class CollisionManager {
             // According to the Minecraft Wiki, when sneaking:
             // - In Bedrock Edition, the height becomes 1.65 blocks, allowing movement through spaces as small as 1.75 (2 - 1⁄4) blocks high.
             // - In Java Edition, the height becomes 1.5 blocks.
+            // TODO: Have this depend on the player's literal bounding box variable
             if (session.isSneaking()) {
                 playerBoundingBox.setSizeY(1.5);
             } else {
@@ -113,6 +118,65 @@ public class CollisionManager {
         }
     }
 
+    /**
+     * Adjust the Bedrock position before sending to the Java server to account for inaccuracies in movement between
+     * the two versions.
+     *
+     * @param bedrockPosition the current Bedrock position of the client
+     * @param onGround whether the Bedrock player is on the ground
+     * @return the position to send to the Java server, or null to cancel sending the packet
+     */
+    public Vector3d adjustBedrockPosition(Vector3f bedrockPosition, boolean onGround) {
+        // We need to parse the float as a string since casting a float to a double causes us to
+        // lose precision and thus, causes players to get stuck when walking near walls
+        double javaY = bedrockPosition.getY() - EntityType.PLAYER.getOffset();
+
+        Vector3d position = Vector3d.from(Double.parseDouble(Float.toString(bedrockPosition.getX())), javaY,
+                Double.parseDouble(Float.toString(bedrockPosition.getZ())));
+
+        if (session.getConnector().getConfig().isCacheChunks()) {
+            // With chunk caching, we can do some proper collision checks
+            updatePlayerBoundingBox(position);
+
+            // Correct player position
+            if (!correctPlayerPosition()) {
+                // Cancel the movement if it needs to be cancelled
+                recalculatePosition();
+                return null;
+            }
+
+            position = Vector3d.from(playerBoundingBox.getMiddleX(),
+                    playerBoundingBox.getMiddleY() - (playerBoundingBox.getSizeY() / 2),
+                    playerBoundingBox.getMiddleZ());
+        } else {
+            // When chunk caching is off, we have to rely on this
+            // It rounds the Y position up to the nearest 0.5
+            // This snaps players to snap to the top of stairs and slabs like on Java Edition
+            // However, it causes issues such as the player floating on carpets
+            if (onGround) javaY = Math.ceil(javaY * 2) / 2;
+            position = position.up(javaY - position.getY());
+        }
+
+        return position;
+    }
+
+    // TODO: This makes the player look upwards for some reason, rotation values must be wrong
+    public void recalculatePosition() {
+        PlayerEntity entity = session.getPlayerEntity();
+        // Gravity might need to be reset...
+        SetEntityDataPacket entityDataPacket = new SetEntityDataPacket();
+        entityDataPacket.setRuntimeEntityId(entity.getGeyserId());
+        entityDataPacket.getMetadata().putAll(entity.getMetadata());
+        session.sendUpstreamPacket(entityDataPacket);
+
+        MovePlayerPacket movePlayerPacket = new MovePlayerPacket();
+        movePlayerPacket.setRuntimeEntityId(entity.getGeyserId());
+        movePlayerPacket.setPosition(entity.getPosition());
+        movePlayerPacket.setRotation(entity.getBedrockRotation());
+        movePlayerPacket.setMode(MovePlayerPacket.Mode.NORMAL);
+        session.sendUpstreamPacket(movePlayerPacket);
+    }
+
     public List<Vector3i> getPlayerCollidableBlocks() {
         List<Vector3i> blocks = new ArrayList<>();
 

connector/src/main/java/org/geysermc/connector/utils/DimensionUtils.java

@@ -58,10 +58,6 @@ public class DimensionUtils {
         int bedrockDimension = javaToBedrock(javaDimension);
         Entity player = session.getPlayerEntity();
 
-        if (session.getMovementSendIfIdle() != null) {
-            session.getMovementSendIfIdle().cancel(true);
-        }
-
         session.getEntityCache().removeAllEntities();
         session.getItemFrameCache().clear();
         session.getSkullCache().clear();