Add support for nicer interaction event handling of player inventories

Author: Aeltumn

examples/src/main/kotlin/com/noxcrew/interfaces/example/ChangingTitleExampleInterface.kt

@@ -1,10 +1,9 @@
 package com.noxcrew.interfaces.example
 
-import com.noxcrew.interfaces.drawable.Drawable
+import com.noxcrew.interfaces.drawable.Drawable.Companion.drawable
 import com.noxcrew.interfaces.element.StaticElement
 import com.noxcrew.interfaces.interfaces.Interface
 import com.noxcrew.interfaces.interfaces.buildChestInterface
-import com.noxcrew.interfaces.interfaces.buildCombinedInterface
 import com.noxcrew.interfaces.properties.interfaceProperty
 import net.kyori.adventure.text.Component
 import org.bukkit.Material
@@ -17,6 +16,9 @@ public class ChangingTitleExampleInterface : RegistrableInterface {
     override fun create(): Interface<*, *> = buildChestInterface {
         rows = 1
 
+        // Allow clicking the player inventory but not anything in the top inventory
+        allowClickingOwnInventoryIfClickingEmptySlotsIsPrevented = true
+
         val numberProperty = interfaceProperty(0)
         var number by numberProperty
 
@@ -26,9 +28,11 @@ public class ChangingTitleExampleInterface : RegistrableInterface {
             val item = ItemStack(Material.STICK)
                 .name("number -> $number")
 
-            pane[0, 4] = StaticElement(Drawable.drawable(item)) {
+            pane[0, 4] = StaticElement(drawable(item)) {
                 number += 1
             }
+
+            pane[0, 6] = StaticElement(drawable(Material.COMPASS))
         }
     }
 }

examples/src/main/kotlin/com/noxcrew/interfaces/example/ExamplePlugin.kt

@@ -154,6 +154,13 @@ public class ExamplePlugin : JavaPlugin(), Listener {
     }
 
     private fun playerInterface() = buildPlayerInterface {
+        // Use modern logic to only cancel the item interaction and not block interactions while
+        // using this interface
+        onlyCancelItemInteraction = true
+
+        // Prioritise block interactions!
+        prioritiseBlockInteractions = true
+
         withTransform { pane, _ ->
             val item = ItemStack(Material.COMPASS).name("interfaces example")
 

interfaces/src/main/kotlin/com/noxcrew/interfaces/InterfacesListeners.kt

@@ -1,5 +1,7 @@
 package com.noxcrew.interfaces
 
+import com.destroystokyo.paper.MaterialSetTag
+import com.destroystokyo.paper.MaterialTags
 import com.github.benmanes.caffeine.cache.Cache
 import com.github.benmanes.caffeine.cache.Caffeine
 import com.noxcrew.interfaces.Constants.SCOPE
@@ -16,9 +18,11 @@ import io.papermc.paper.event.player.AsyncChatEvent
 import kotlinx.coroutines.launch
 import net.kyori.adventure.text.Component
 import org.bukkit.Bukkit
+import org.bukkit.Material
+import org.bukkit.NamespacedKey
+import org.bukkit.block.Block
 import org.bukkit.entity.HumanEntity
 import org.bukkit.entity.Player
-import org.bukkit.event.Cancellable
 import org.bukkit.event.Event
 import org.bukkit.event.EventHandler
 import org.bukkit.event.EventPriority
@@ -69,6 +73,60 @@ public class InterfacesListeners private constructor(private val plugin: Plugin)
             Reason.UNKNOWN,
             Reason.PLUGIN
         )
+
+        /** An incomplete set of blocks that have some interaction when clicked on. */
+        private val CLICKABLE_BLOCKS: MaterialSetTag =
+            MaterialSetTag(NamespacedKey("interfaces", "clickable-blocks"))
+                .add(
+                    MaterialTags.WOODEN_DOORS,
+                    MaterialTags.WOODEN_TRAPDOORS,
+                    MaterialTags.FENCE_GATES,
+                    MaterialSetTag.BUTTONS,
+                )
+                // Add blocks with inventories
+                .add(
+                    Material.CHEST,
+                    Material.ENDER_CHEST,
+                    Material.TRAPPED_CHEST,
+                    Material.BARREL,
+                    Material.FURNACE,
+                    Material.BLAST_FURNACE,
+                    Material.SMOKER,
+                    Material.CRAFTING_TABLE,
+                    Material.LOOM,
+                    Material.CARTOGRAPHY_TABLE,
+                    Material.ENCHANTING_TABLE,
+                    Material.SMITHING_TABLE,
+                )
+                .add(Material.LEVER)
+                .add(Material.CAKE)
+                // Add copper doors & trapdoors as they do not have their own tags
+                .add(
+                    Material.COPPER_DOOR,
+                    Material.EXPOSED_COPPER_DOOR,
+                    Material.WEATHERED_COPPER_DOOR,
+                    Material.OXIDIZED_COPPER_DOOR,
+                )
+                .add(
+                    Material.WAXED_COPPER_DOOR,
+                    Material.WAXED_EXPOSED_COPPER_DOOR,
+                    Material.WAXED_WEATHERED_COPPER_DOOR,
+                    Material.WAXED_OXIDIZED_COPPER_DOOR,
+                )
+                .add(
+                    Material.COPPER_TRAPDOOR,
+                    Material.EXPOSED_COPPER_TRAPDOOR,
+                    Material.WEATHERED_COPPER_TRAPDOOR,
+                    Material.OXIDIZED_COPPER_TRAPDOOR,
+                )
+                .add(
+                    Material.WAXED_COPPER_TRAPDOOR,
+                    Material.WAXED_EXPOSED_COPPER_TRAPDOOR,
+                    Material.WAXED_WEATHERED_COPPER_TRAPDOOR,
+                    Material.WAXED_OXIDIZED_COPPER_TRAPDOOR,
+                )
+                // You can click signs to edit them
+                .add(MaterialTags.SIGNS)
     }
 
     /** Stores data for a single chat query. */
@@ -183,7 +241,11 @@ public class InterfacesListeners private constructor(private val plugin: Plugin)
         val view = convertHolderToInterfaceView(holder) ?: return
         val clickedPoint = clickedPoint(view, event) ?: return
         val isPlayerInventory = (event.clickedInventory ?: event.inventory).holder is Player
-        handleClick(view, clickedPoint, event.click, event, event.hotbarButton, isPlayerInventory)
+
+        // Run base click handling
+        if (handleClick(view, clickedPoint, event.click, event.hotbarButton, isPlayerInventory)) {
+            event.isCancelled = true
+        }
 
         // If the event is not cancelled we add extra prevention checks if any of the involved
         // slots are not allowed to be modified!
@@ -263,6 +325,10 @@ public class InterfacesListeners private constructor(private val plugin: Plugin)
         setOpenInterface(event.player.uniqueId, null)
     }
 
+    /** Returns whether [block] will trigger some interaction if clicked with [item]. */
+    private fun hasInteraction(block: Block, item: ItemStack): Boolean =
+        CLICKABLE_BLOCKS.isTagged(block)
+
     @EventHandler(priority = EventPriority.LOW)
     public fun onInteract(event: PlayerInteractEvent) {
         if (event.action == Action.PHYSICAL) return
@@ -271,6 +337,13 @@ public class InterfacesListeners private constructor(private val plugin: Plugin)
         val player = event.player
         val view = getOpenInterface(player.uniqueId) ?: return
 
+        // If we are prioritizing block interactions we assure they are not happening first
+        if (view.builder.prioritiseBlockInteractions) {
+            // This is a bit messy because Bukkit doesn't cleanly give access to the block interactions. If you are
+            // using this setting feel free to PR more logic into this method.
+            if (event.clickedBlock != null && hasInteraction(event.clickedBlock!!, event.item ?: ItemStack.empty())) return
+        }
+
         val clickedPoint = view.backing.relativizePlayerInventorySlot(
             if (event.hand == EquipmentSlot.HAND) {
                 GridPoint.at(3, player.inventory.heldItemSlot)
@@ -289,7 +362,14 @@ public class InterfacesListeners private constructor(private val plugin: Plugin)
             return
         }
 
-        handleClick(view, clickedPoint, click, event, -1, true)
+        if (handleClick(view, clickedPoint, click, -1, true)) {
+            // Support modern behavior where we don't interfere with block interactions
+            if (view.builder.onlyCancelItemInteraction) {
+                event.setUseItemInHand(Event.Result.DENY)
+            } else {
+                event.isCancelled = true
+            }
+        }
     }
 
     @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
@@ -412,25 +492,23 @@ public class InterfacesListeners private constructor(private val plugin: Plugin)
         view: AbstractInterfaceView<*, *, *>,
         clickedPoint: GridPoint,
         click: ClickType,
-        event: Cancellable,
         slot: Int,
         isPlayerInventory: Boolean
-    ) {
+    ): Boolean {
         // Determine the type of click, if nothing was clicked we allow it
         val raw = view.pane.getRaw(clickedPoint)
 
         // Optionally cancel clicking on other slots
         if (raw == null) {
             if (view.builder.preventClickingEmptySlots && !(view.builder.allowClickingOwnInventoryIfClickingEmptySlotsIsPrevented && isPlayerInventory)) {
-                event.isCancelled = true
+                return true
             }
-            return
+            return false
         }
 
         // Automatically cancel if throttling or already processing
         if (view.isProcessingClick || shouldThrottle(view.player)) {
-            event.isCancelled = true
-            return
+            return true
         }
 
         // Only allow one click to be processed at the same time
@@ -464,8 +542,9 @@ public class InterfacesListeners private constructor(private val plugin: Plugin)
 
         // Update the cancellation state of the event
         if (completedClickHandler.cancelled) {
-            event.isCancelled = true
+            return true
         }
+        return false
     }
 
     /** Converts a bukkit [action] to a [ClickType]. */

interfaces/src/main/kotlin/com/noxcrew/interfaces/interfaces/InterfaceProperties.kt

@@ -33,6 +33,12 @@ public open class InterfaceProperties<P : Pane> {
     /** A post-processor applied to all items placed in the inventory. */
     public var itemPostProcessor: ((ItemStack) -> Unit)? = {}
 
+    /** Whether interaction should only cancel the item effects and not the world effects. */
+    public var onlyCancelItemInteraction: Boolean = false
+
+    /** Whether to prioritise block interactions over item interactions when right-clicking. */
+    public var prioritiseBlockInteractions: Boolean = false
+
     /** Whether clicking on empty slots should be cancelled. */
     public var preventClickingEmptySlots: Boolean = true