Merge bdc53bc09f into 5c23713c03

src/main/java/net/minestom/server/event/player/PlayerChangeHeldSlotEvent.java

@@ -3,6 +3,7 @@ package net.minestom.server.event.player;
 import net.minestom.server.entity.Player;
 import net.minestom.server.event.trait.CancellableEvent;
 import net.minestom.server.event.trait.PlayerInstanceEvent;
+import net.minestom.server.item.ItemStack;
 import net.minestom.server.utils.MathUtils;
 import net.minestom.server.utils.validate.Check;
 import org.jetbrains.annotations.NotNull;
@@ -13,22 +14,50 @@ import org.jetbrains.annotations.NotNull;
 public class PlayerChangeHeldSlotEvent implements PlayerInstanceEvent, CancellableEvent {
 
     private final Player player;
-    private byte slot;
+    private final byte oldSlot;
+    private byte newSlot;
 
     private boolean cancelled;
 
-    public PlayerChangeHeldSlotEvent(@NotNull Player player, byte slot) {
+    public PlayerChangeHeldSlotEvent(@NotNull Player player, byte oldSlot, byte newSlot) {
         this.player = player;
-        this.slot = slot;
+        this.oldSlot = oldSlot;
+        this.newSlot = newSlot;
     }
 
     /**
-     * Gets the slot which the player will held.
-     *
+     * Gets the slot number that the player is currently holding
+     * @return The slot index that the player currently is holding
+     */
+    public int getOldSlot() {
+        return oldSlot;
+    }
+
+    /**
+     * Gets the slot which the player will hold.
+     * @deprecated Use {{@link #getNewSlot()}} instead
      * @return the held slot
      */
+    @Deprecated
     public byte getSlot() {
-        return slot;
+        return newSlot;
+    }
+
+    /**
+     * Gets the slot which the player will hold.
+     * @return the held slot
+     */
+    public byte getNewSlot() { return newSlot; }
+
+    /**
+     * Changes the final held slot of the player.
+     * @deprecated Use {{@link #setNewSlot(byte)}} instead
+     * @param slot the new held slot
+     * @throws IllegalArgumentException if <code>slot</code> is not between 0 and 8
+     */
+    public void setSlot(byte slot) {
+        Check.argCondition(!MathUtils.isBetween(slot, 0, 8), "The held slot needs to be between 0 and 8");
+        this.newSlot = slot;
     }
 
     /**
@@ -37,9 +66,25 @@ public class PlayerChangeHeldSlotEvent implements PlayerInstanceEvent, Cancellab
      * @param slot the new held slot
      * @throws IllegalArgumentException if <code>slot</code> is not between 0 and 8
      */
-    public void setSlot(byte slot) {
+    public void setNewSlot(byte slot) {
         Check.argCondition(!MathUtils.isBetween(slot, 0, 8), "The held slot needs to be between 0 and 8");
-        this.slot = slot;
+        this.newSlot = slot;
+    }
+
+    /**
+     * Gets the ItemStack in the player's currently held slot
+     * @return The ItemStack in the player's currently held slot
+     */
+    public ItemStack getItemInOldSlot() {
+        return player.getInventory().getItemStack(oldSlot);
+    }
+
+    /**
+     * Gets the ItemStack in the slot the player will hold
+     * @return The ItemStack in the final held slot of the player
+     */
+    public ItemStack getItemInNewSlot() {
+        return player.getInventory().getItemStack(newSlot);
     }
 
     @Override

src/main/java/net/minestom/server/event/player/PlayerSpawnEvent.java

@@ -1,15 +1,14 @@
 package net.minestom.server.event.player;
 
 import net.minestom.server.entity.Player;
-import net.minestom.server.event.trait.PlayerEvent;
+import net.minestom.server.event.trait.PlayerInstanceEvent;
 import net.minestom.server.instance.Instance;
 import org.jetbrains.annotations.NotNull;
 
 /**
  * Called when a new instance is set for a player.
  */
-public class PlayerSpawnEvent implements PlayerEvent {
-
+public class PlayerSpawnEvent implements PlayerInstanceEvent {
     private final Player player;
     private final Instance spawnInstance;
     private final boolean firstSpawn;
@@ -21,11 +20,12 @@ public class PlayerSpawnEvent implements PlayerEvent {
     }
 
     /**
-     * Gets the entity new instance.
+     * Gets the player's new instance.
      *
      * @return the instance
      */
     @NotNull
+    @Deprecated
     public Instance getSpawnInstance() {
         return spawnInstance;
     }

src/main/java/net/minestom/server/listener/PlayerHeldListener.java

@@ -14,18 +14,19 @@ public class PlayerHeldListener {
             return;
         }
 
-        final byte slot = (byte) packet.slot();
+        final byte newSlot = (byte) packet.slot();
+        final byte oldSlot = player.getHeldSlot();
 
-        PlayerChangeHeldSlotEvent changeHeldSlotEvent = new PlayerChangeHeldSlotEvent(player, slot);
+        PlayerChangeHeldSlotEvent changeHeldSlotEvent = new PlayerChangeHeldSlotEvent(player, oldSlot, newSlot);
         EventDispatcher.call(changeHeldSlotEvent);
 
         if (!changeHeldSlotEvent.isCancelled()) {
             // Event hasn't been canceled, process it
 
-            final byte resultSlot = changeHeldSlotEvent.getSlot();
+            final byte resultSlot = changeHeldSlotEvent.getNewSlot();
 
             // If the held slot has been changed by the event, send the change to the player
-            if (resultSlot != slot) {
+            if (resultSlot != oldSlot) {
                 player.setHeldItemSlot(resultSlot);
             } else {
                 // Otherwise, simply refresh the player field
@@ -33,7 +34,7 @@ public class PlayerHeldListener {
             }
         } else {
             // Event has been canceled, send the last held slot to refresh the client
-            player.setHeldItemSlot(player.getHeldSlot());
+            player.setHeldItemSlot(oldSlot);
         }
     }
 

src/test/java/net/minestom/server/entity/PlayerHeldIntegrationTest.java

@@ -45,10 +45,42 @@ public class PlayerHeldIntegrationTest {
         var listener = env.listen(PlayerChangeHeldSlotEvent.class);
         listener.followup(event -> {
             assertEquals(player, event.getPlayer());
-            assertEquals(1, event.getSlot());
+            assertEquals(0, event.getOldSlot());
+            assertEquals(1, event.getNewSlot());
         });
         player.interpretPacketQueue();
         assertEquals(ItemStack.of(Material.STONE), player.getItemInMainHand());
         assertEquals(1, player.getHeldSlot());
     }
+
+    @Test
+    public void playerChangingSlots(Env env) {
+        var instance = env.createFlatInstance();
+        var connection = env.createConnection();
+        var player = connection.connect(instance, new Pos(0, 40, 0)).join();
+
+        player.getInventory().setItemStack(1, ItemStack.of(Material.STONE));
+        player.getInventory().setItemStack(3, ItemStack.of(Material.OAK_PLANKS));
+
+        player.addPacketToQueue(new ClientHeldItemChangePacket((short) 1));
+        var listener = env.listen(PlayerChangeHeldSlotEvent.class);
+        listener.followup(event -> {
+            assertEquals(player, event.getPlayer());
+            assertEquals(0, event.getOldSlot());
+            assertEquals(1, event.getNewSlot());
+            assertEquals(ItemStack.AIR, event.getItemInOldSlot());
+            assertEquals(ItemStack.of(Material.STONE), event.getItemInNewSlot());
+        });
+        player.interpretPacketQueue();
+
+        player.addPacketToQueue(new ClientHeldItemChangePacket((short) 3));
+        listener.followup(event -> {
+            assertEquals(player, event.getPlayer());
+            assertEquals(1, event.getOldSlot());
+            assertEquals(3, event.getNewSlot());
+            assertEquals(ItemStack.of(Material.STONE), event.getItemInOldSlot());
+            assertEquals(ItemStack.of(Material.OAK_PLANKS), event.getItemInNewSlot());
+        });
+        player.interpretPacketQueue();
+    }
 }