Add methods to change entity physics (#10334)

1 files changed, 229 insertions, 0 deletions

diff --git a/patches/server/0764-More-Teleport-API.patch b/patches/server/0764-More-Teleport-API.patch
new file mode 100644
index 0000000000..c593fa72c5
--- /dev/null
+++ b/patches/server/0764-More-Teleport-API.patch
@@ -0,0 +1,229 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <[email protected]>
+Date: Sun, 5 Sep 2021 12:15:59 -0400
+Subject: [PATCH] More Teleport API
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 5775d071f714e7b9d959bfa94510b865f489e68e..27eb4bc4d1276ea36b97d0faeed2acee8b7a64cc 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -1558,11 +1558,17 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+             return false; // CraftBukkit - Return event status
+         }
+ 
+-        PlayerTeleportEvent event = new PlayerTeleportEvent(player, from.clone(), to.clone(), cause);
++        // Paper start - Teleport API
++        Set<io.papermc.paper.entity.TeleportFlag.Relative> relativeFlags = java.util.EnumSet.noneOf(io.papermc.paper.entity.TeleportFlag.Relative.class);
++        for (RelativeMovement relativeArgument : set) {
++            relativeFlags.add(org.bukkit.craftbukkit.entity.CraftPlayer.toApiRelativeFlag(relativeArgument));
++        }
++        PlayerTeleportEvent event = new PlayerTeleportEvent(player, from.clone(), to.clone(), cause, java.util.Set.copyOf(relativeFlags));
++        // Paper end - Teleport API
+         this.cserver.getPluginManager().callEvent(event);
+ 
+         if (event.isCancelled() || !to.equals(event.getTo())) {
+-            set.clear(); // Can't relative teleport
++            // set.clear(); // Can't relative teleport // Paper - Teleport API; Now you can!
+             to = event.isCancelled() ? event.getFrom() : event.getTo();
+             d0 = to.getX();
+             d1 = to.getY();
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+index 88e05b8ec5f442b3ad14e3b39a06beeca5c169ae..70c1b20c2b25fbe53255f1753d86570c975767ab 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+@@ -219,15 +219,36 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
+ 
+     @Override
+     public boolean teleport(Location location, TeleportCause cause) {
++        // Paper start - Teleport passenger API
++        return teleport(location, cause, new io.papermc.paper.entity.TeleportFlag[0]);
++    }
++
++    @Override
++    public boolean teleport(Location location, TeleportCause cause, io.papermc.paper.entity.TeleportFlag... flags) {
++        // Paper end
+         Preconditions.checkArgument(location != null, "location cannot be null");
+         location.checkFinite();
++        // Paper start - Teleport passenger API
++        Set<io.papermc.paper.entity.TeleportFlag> flagSet = Set.of(flags);
++        boolean dismount = !flagSet.contains(io.papermc.paper.entity.TeleportFlag.EntityState.RETAIN_VEHICLE);
++        boolean ignorePassengers = flagSet.contains(io.papermc.paper.entity.TeleportFlag.EntityState.RETAIN_PASSENGERS);
++        // Don't allow teleporting between worlds while keeping passengers
++        if (flagSet.contains(io.papermc.paper.entity.TeleportFlag.EntityState.RETAIN_PASSENGERS) && this.entity.isVehicle() && location.getWorld() != this.getWorld()) {
++            return false;
++        }
++
++        // Don't allow to teleport between worlds if remaining on vehicle
++        if (!dismount && this.entity.isPassenger() && location.getWorld() != this.getWorld()) {
++            return false;
++        }
++        // Paper end
+ 
+-        if (this.entity.isVehicle() || this.entity.isRemoved()) {
++        if ((!ignorePassengers && this.entity.isVehicle()) || this.entity.isRemoved()) { // Paper - Teleport passenger API
+             return false;
+         }
+ 
+         // If this entity is riding another entity, we must dismount before teleporting.
+-        this.entity.stopRiding();
++        if (dismount) this.entity.stopRiding(); // Paper - Teleport passenger API
+ 
+         // Let the server handle cross world teleports
+         if (location.getWorld() != null && !location.getWorld().equals(this.getWorld())) {
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 11e144bf561cc3c4dc1d8b712f915cc167f4d4ed..f606250106f1bcf5870dff1167f2902f85f7784a 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -1195,13 +1195,101 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+ 
+     @Override
+     public void setRotation(float yaw, float pitch) {
+-        throw new UnsupportedOperationException("Cannot set rotation of players. Consider teleporting instead.");
++        // Paper start - Teleport API
++        Location targetLocation = this.getEyeLocation();
++        targetLocation.setYaw(yaw);
++        targetLocation.setPitch(pitch);
++
++        org.bukkit.util.Vector direction = targetLocation.getDirection();
++        direction.multiply(9999999); // We need to move the target block.. FAR out
++        targetLocation.add(direction);
++        this.lookAt(targetLocation, io.papermc.paper.entity.LookAnchor.EYES);
++        // Paper end
+     }
+ 
+     @Override
+     public boolean teleport(Location location, PlayerTeleportEvent.TeleportCause cause) {
++        // Paper start - Teleport API
++        return this.teleport(location, cause, new io.papermc.paper.entity.TeleportFlag[0]);
++    }
++
++    @Override
++    public void lookAt(@NotNull org.bukkit.entity.Entity entity, @NotNull io.papermc.paper.entity.LookAnchor playerAnchor, @NotNull io.papermc.paper.entity.LookAnchor entityAnchor) {
++        this.getHandle().lookAt(toNmsAnchor(playerAnchor), ((CraftEntity) entity).getHandle(), toNmsAnchor(entityAnchor));
++    }
++
++    @Override
++    public void lookAt(double x, double y, double z, @NotNull io.papermc.paper.entity.LookAnchor playerAnchor) {
++        this.getHandle().lookAt(toNmsAnchor(playerAnchor), new Vec3(x, y, z));
++    }
++
++    public static net.minecraft.commands.arguments.EntityAnchorArgument.Anchor toNmsAnchor(io.papermc.paper.entity.LookAnchor nmsAnchor) {
++        return switch (nmsAnchor) {
++            case EYES -> net.minecraft.commands.arguments.EntityAnchorArgument.Anchor.EYES;
++            case FEET -> net.minecraft.commands.arguments.EntityAnchorArgument.Anchor.FEET;
++        };
++    }
++
++    public static io.papermc.paper.entity.LookAnchor toApiAnchor(net.minecraft.commands.arguments.EntityAnchorArgument.Anchor playerAnchor) {
++        return switch (playerAnchor) {
++            case EYES -> io.papermc.paper.entity.LookAnchor.EYES;
++            case FEET -> io.papermc.paper.entity.LookAnchor.FEET;
++        };
++    }
++
++    public static net.minecraft.world.entity.RelativeMovement toNmsRelativeFlag(io.papermc.paper.entity.TeleportFlag.Relative apiFlag) {
++        return switch (apiFlag) {
++            case X -> net.minecraft.world.entity.RelativeMovement.X;
++            case Y -> net.minecraft.world.entity.RelativeMovement.Y;
++            case Z -> net.minecraft.world.entity.RelativeMovement.Z;
++            case PITCH -> net.minecraft.world.entity.RelativeMovement.X_ROT;
++            case YAW -> net.minecraft.world.entity.RelativeMovement.Y_ROT;
++        };
++    }
++
++    public static io.papermc.paper.entity.TeleportFlag.Relative toApiRelativeFlag(net.minecraft.world.entity.RelativeMovement nmsFlag) {
++        return switch (nmsFlag) {
++            case X -> io.papermc.paper.entity.TeleportFlag.Relative.X;
++            case Y -> io.papermc.paper.entity.TeleportFlag.Relative.Y;
++            case Z -> io.papermc.paper.entity.TeleportFlag.Relative.Z;
++            case X_ROT -> io.papermc.paper.entity.TeleportFlag.Relative.PITCH;
++            case Y_ROT -> io.papermc.paper.entity.TeleportFlag.Relative.YAW;
++        };
++    }
++
++    @Override
++    public boolean teleport(Location location, org.bukkit.event.player.PlayerTeleportEvent.TeleportCause cause, io.papermc.paper.entity.TeleportFlag... flags) {
++        Set<io.papermc.paper.entity.TeleportFlag.Relative> relativeArguments;
++        Set<io.papermc.paper.entity.TeleportFlag> allFlags;
++        if (flags.length == 0) {
++            relativeArguments = Set.of();
++            allFlags = Set.of();
++        } else {
++            relativeArguments = java.util.EnumSet.noneOf(io.papermc.paper.entity.TeleportFlag.Relative.class);
++            allFlags = new HashSet<>();
++            for (io.papermc.paper.entity.TeleportFlag flag : flags) {
++                if (flag instanceof final io.papermc.paper.entity.TeleportFlag.Relative relativeTeleportFlag) {
++                    relativeArguments.add(relativeTeleportFlag);
++                }
++                allFlags.add(flag);
++            }
++        }
++        boolean dismount = !allFlags.contains(io.papermc.paper.entity.TeleportFlag.EntityState.RETAIN_VEHICLE);
++        boolean ignorePassengers = allFlags.contains(io.papermc.paper.entity.TeleportFlag.EntityState.RETAIN_PASSENGERS);
++        // Paper end - Teleport API
+         Preconditions.checkArgument(location != null, "location");
+         Preconditions.checkArgument(location.getWorld() != null, "location.world");
++        // Paper start - Teleport passenger API
++        // Don't allow teleporting between worlds while keeping passengers
++        if (ignorePassengers && entity.isVehicle() && location.getWorld() != this.getWorld()) {
++            return false;
++        }
++
++        // Don't allow to teleport between worlds if remaining on vehicle
++        if (!dismount && entity.isPassenger() && location.getWorld() != this.getWorld()) {
++            return false;
++        }
++        // Paper end
+         location.checkFinite();
+ 
+         ServerPlayer entity = this.getHandle();
+@@ -1214,7 +1302,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+             return false;
+         }
+ 
+-        if (entity.isVehicle()) {
++        if (entity.isVehicle() && !ignorePassengers) { // Paper - Teleport API
+             return false;
+         }
+ 
+@@ -1223,7 +1311,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+         // To = Players new Location if Teleport is Successful
+         Location to = location;
+         // Create & Call the Teleport Event.
+-        PlayerTeleportEvent event = new PlayerTeleportEvent(this, from, to, cause);
++        PlayerTeleportEvent event = new PlayerTeleportEvent(this, from, to, cause, Set.copyOf(relativeArguments)); // Paper - Teleport API
+         this.server.getPluginManager().callEvent(event);
+ 
+         // Return False to inform the Plugin that the Teleport was unsuccessful/cancelled.
+@@ -1232,7 +1320,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+         }
+ 
+         // If this player is riding another entity, we must dismount before teleporting.
+-        entity.stopRiding();
++        if (dismount) entity.stopRiding(); // Paper - Teleport API
+ 
+         // SPIGOT-5509: Wakeup, similar to riding
+         if (this.isSleeping()) {
+@@ -1248,13 +1336,19 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+         ServerLevel toWorld = ((CraftWorld) to.getWorld()).getHandle();
+ 
+         // Close any foreign inventory
+-        if (this.getHandle().containerMenu != this.getHandle().inventoryMenu) {
++        if (this.getHandle().containerMenu != this.getHandle().inventoryMenu && !allFlags.contains(io.papermc.paper.entity.TeleportFlag.EntityState.RETAIN_OPEN_INVENTORY)) { // Paper
+             this.getHandle().closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason.TELEPORT); // Paper - Inventory close reason
+         }
+ 
+         // Check if the fromWorld and toWorld are the same.
+         if (fromWorld == toWorld) {
+-            entity.connection.teleport(to);
++            // Paper start - Teleport API
++            final Set<net.minecraft.world.entity.RelativeMovement> nms = java.util.EnumSet.noneOf(net.minecraft.world.entity.RelativeMovement.class);
++            for (final io.papermc.paper.entity.TeleportFlag.Relative bukkit : relativeArguments) {
++                nms.add(toNmsRelativeFlag(bukkit));
++            }
++            entity.connection.internalTeleport(to.getX(), to.getY(), to.getZ(), to.getYaw(), to.getPitch(), nms);
++            // Paper end - Teleport API
+         } else {
+             // The respawn reason should never be used if the passed location is non null.
+             this.server.getHandle().respawn(entity, toWorld, true, to, !toWorld.paperConfig().environment.disableTeleportationSuffocationCheck, null); // Paper