Optimize dropped-item section candidates

Author: Arbousier1

.github/workflows/phase2-runtime-ab.yml

@@ -307,17 +307,18 @@ private boolean handlePerformanceCommand(CommandSender sender, String[] args) {
             case "scene" -> {
                 if (args.length < 4) {
                     sender.sendMessage(Component.text(
-                            "Usage: /iv perf scene <static|motion|itemdisplay|textdisplay> " +
+                            "Usage: /iv perf scene <static|motion|itemdisplay|textdisplay|dropped> " +
                                     "<count> [lifetimeTicks] [player]"));
                     return true;
                 }
                 boolean moving = args[2].equalsIgnoreCase("motion");
                 boolean staticItem = args[2].equalsIgnoreCase("static");
                 boolean itemDisplay = args[2].equalsIgnoreCase("itemdisplay");
                 boolean textDisplay = args[2].equalsIgnoreCase("textdisplay");
-                if (!moving && !staticItem && !itemDisplay && !textDisplay) {
+                boolean dropped = args[2].equalsIgnoreCase("dropped");
+                if (!moving && !staticItem && !itemDisplay && !textDisplay && !dropped) {
                     sender.sendMessage(Component.text(
-                            "[InteractionVisualizer] Scene type must be static, motion, itemdisplay, or textdisplay."));
+                            "[InteractionVisualizer] Scene type must be static, motion, itemdisplay, textdisplay, or dropped."));
                     return true;
                 }
                 long defaultLifetime = moving ? 80L : 200L;
@@ -343,12 +344,15 @@ private boolean handlePerformanceCommand(CommandSender sender, String[] args) {
                     return true;
                 }
                 int count = parseInteger(args[3], 1);
-                int spawned = itemDisplay || textDisplay
+                int spawned = dropped
+                        ? PerformanceScene.spawnDroppedItems(player, count, lifetime)
+                        : itemDisplay || textDisplay
                         ? PerformanceScene.spawnDisplay(player, textDisplay, count, lifetime)
                         : PerformanceScene.spawn(player, moving, count, lifetime);
                 String sceneName = moving ? "moving" : staticItem ? "static"
-                        : itemDisplay ? "itemdisplay" : "textdisplay";
-                String entityLabel = staticItem || moving ? " benchmark items" : " benchmark entities";
+                        : itemDisplay ? "itemdisplay" : textDisplay ? "textdisplay" : "dropped";
+                String entityLabel = staticItem || moving || dropped
+                        ? " benchmark items" : " benchmark entities";
                 sender.sendMessage(Component.text("[InteractionVisualizer] Spawned " + spawned + " "
                         + sceneName + entityLabel + " for " + lifetime + " ticks."));
             }
@@ -708,7 +712,7 @@ public List<String> onTabComplete(CommandSender sender, Command cmd, String labe
             case 3:
                 if (args[0].equalsIgnoreCase("perf") && args[1].equalsIgnoreCase("scene")
                         && sender.hasPermission("interactionvisualizer.performance")) {
-                    for (String option : List.of("static", "motion", "itemdisplay", "textdisplay")) {
+                    for (String option : List.of("static", "motion", "itemdisplay", "textdisplay", "dropped")) {
                         if (option.startsWith(args[2].toLowerCase())) {
                             tab.add(option);
                         }

common/src/main/java/com/loohp/interactionvisualizer/Commands.java

@@ -21,6 +21,7 @@
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.Material;
+import org.bukkit.World;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.util.Vector;
@@ -40,6 +41,7 @@ public final class PerformanceScene {
     private static final int MAX_ITEMS = 8_192;
     private static final long MAX_LIFETIME_TICKS = 12_000L;
     private static final Map<UUID, Set<VisualizerEntity>> scenes = new HashMap<>();
+    private static final Map<UUID, Set<org.bukkit.entity.Item>> droppedScenes = new HashMap<>();
 
     private PerformanceScene() {
     }
@@ -121,6 +123,44 @@ public static int spawnDisplay(Player owner, boolean text, int requestedCount,
         return count;
     }
 
+    /** Creates real Paper Item entities for the dropped-label runtime factor. */
+    public static int spawnDroppedItems(Player owner, int requestedCount,
+                                        long requestedLifetimeTicks) {
+        int count = Math.max(1, Math.min(MAX_ITEMS, requestedCount));
+        long lifetimeTicks = Math.max(1L, Math.min(MAX_LIFETIME_TICKS, requestedLifetimeTicks));
+        clear(owner);
+
+        World world = owner.getWorld();
+        Location center = owner.getLocation().add(0.0D, 1.5D, 0.0D);
+        int width = (int) Math.ceil(Math.sqrt(count));
+        double spacing = 1.25D;
+        double offset = (width - 1) * spacing / 2.0D;
+        Set<org.bukkit.entity.Item> items = new HashSet<>(count);
+        for (int index = 0; index < count; index++) {
+            double x = center.getX() + index % width * spacing - offset;
+            double z = center.getZ() + index / width * spacing - offset;
+            Location location = new Location(world, x, center.getY(), z);
+            location.getChunk().load();
+            ItemStack stack = new ItemStack(Material.STONE, index % 64 + 1);
+            int ordinal = index;
+            stack.editMeta(meta -> meta.customName(Component.text("iv-dropped-benchmark-" + ordinal)));
+            org.bukkit.entity.Item item = world.dropItem(location, stack, entity -> {
+                entity.setGravity(false);
+                entity.setVelocity(new Vector());
+                entity.setPickupDelay(Short.MAX_VALUE - 1);
+                entity.setUnlimitedLifetime(true);
+                entity.setPersistent(false);
+            });
+            items.add(item);
+        }
+
+        UUID ownerId = owner.getUniqueId();
+        droppedScenes.put(ownerId, items);
+        Scheduler.runTaskLater(InteractionVisualizer.plugin,
+                () -> expireDropped(ownerId, items), lifetimeTicks, owner.getLocation());
+        return count;
+    }
+
     public static void clear(Player owner) {
         clear(owner.getUniqueId());
     }
@@ -131,6 +171,10 @@ public static void clear(UUID ownerId) {
         if (previous != null) {
             removeEntities(previous);
         }
+        Set<org.bukkit.entity.Item> dropped = droppedScenes.remove(ownerId);
+        if (dropped != null) {
+            removeDroppedItems(dropped);
+        }
     }
 
     /** Deterministically removes every disposable benchmark scene. */
@@ -140,10 +184,15 @@ public static void shutdown() {
         for (Set<VisualizerEntity> entities : remaining) {
             removeEntities(entities);
         }
+        List<Set<org.bukkit.entity.Item>> remainingDropped = new ArrayList<>(droppedScenes.values());
+        droppedScenes.clear();
+        for (Set<org.bukkit.entity.Item> items : remainingDropped) {
+            removeDroppedItems(items);
+        }
     }
 
     public static int retainedStateCount() {
-        return scenes.size();
+        return scenes.size() + droppedScenes.size();
     }
 
     private static void expire(UUID ownerId, Set<VisualizerEntity> entities) {
@@ -152,6 +201,12 @@ private static void expire(UUID ownerId, Set<VisualizerEntity> entities) {
         }
     }
 
+    private static void expireDropped(UUID ownerId, Set<org.bukkit.entity.Item> items) {
+        if (droppedScenes.remove(ownerId, items)) {
+            removeDroppedItems(items);
+        }
+    }
+
     private static void removeEntities(Set<VisualizerEntity> entities) {
         for (VisualizerEntity entity : entities) {
             if (entity instanceof Item item) {
@@ -161,4 +216,12 @@ private static void removeEntities(Set<VisualizerEntity> entities) {
             }
         }
     }
+
+    private static void removeDroppedItems(Set<org.bukkit.entity.Item> items) {
+        for (org.bukkit.entity.Item item : items) {
+            if (item.isValid()) {
+                item.remove();
+            }
+        }
+    }
 }