Implement value request system with multiple input methods

- Added BookInputManager for input via writable books.
- Introduced SignInputManager for input through in-game signs.
- Created InventoryRequestManager for selecting values via inventory.
- Added support for multiple input types: STRING, NUMBER, BOOLEAN.
- Implemented PlayerInputManager to manage player-specific input
preferences.
- Developed ValueRequest class to handle value requests with fallback
options.

Author: BenCodez

SimpleAPI/src/main/java/com/bencodez/simpleapi/valuerequest/BookInputManager.java

@@ -0,0 +1,104 @@
+package com.bencodez.simpleapi.valuerequest;
+
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Consumer;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerEditBookEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.plugin.Plugin;
+
+/**
+ * Handles book based value requests. When a player is asked to provide input via
+ * a book they are given a writable book. Once the book is signed the input is
+ * read and passed to the provided callback.
+ */
+public class BookInputManager implements Listener {
+
+    /**
+     * Flag indicating whether the listener has been registered with the
+     * server's plugin manager.
+     */
+    private static boolean registered = false;
+
+    /**
+     * The plugin responsible for registering this listener. Stored for future
+     * requests to ensure correct registration.
+     */
+    private static Plugin plugin;
+
+    /**
+     * Map of player unique identifiers to their pending input callbacks.
+     */
+    private static final Map<UUID, Consumer<String>> callbacks = new ConcurrentHashMap<>();
+
+    /**
+     * Initialise the book input manager. Registers the event listener with the
+     * plugin manager if it has not already been registered.
+     *
+     * @param p the plugin instance used for registration
+     */
+    public static void initialize(Plugin p) {
+        if (!registered) {
+            plugin = p;
+            Bukkit.getPluginManager().registerEvents(new BookInputManager(), p);
+            registered = true;
+        }
+    }
+
+    /**
+     * Prompt a player to provide a value via a writable book. The player will
+     * receive a book in their inventory. Once the book is edited and signed the
+     * contents of all pages will be concatenated and delivered to the provided
+     * callback.
+     *
+     * @param player the player who will receive the book and provide input
+     * @param start  the starting value to display in the book (unused in this
+     *               implementation but reserved for future use)
+     * @param callback the callback to invoke with the input once the player
+     *                 finishes editing the book
+     */
+    public static void requestBookInput(Player player, String start, Consumer<String> callback) {
+        // Ensure the listener is registered with the current plugin
+        if (!registered && plugin != null) {
+            initialize(plugin);
+        }
+        callbacks.put(player.getUniqueId(), callback);
+        ItemStack book = new ItemStack(Material.WRITABLE_BOOK);
+        player.getInventory().addItem(book);
+        player.sendMessage("Please write your value in the book and sign it to submit.");
+    }
+
+    /**
+     * Event handler for when a player edits and signs a book. If the player has
+     * a pending callback in the callbacks map the contents of the book are
+     * concatenated and supplied to the callback. The callback is then removed.
+     *
+     * @param event the book edit event
+     */
+    @EventHandler
+    public void onPlayerEditBook(PlayerEditBookEvent event) {
+        Player player = event.getPlayer();
+        UUID uuid = player.getUniqueId();
+        if (!callbacks.containsKey(uuid)) {
+            return;
+        }
+        Consumer<String> callback = callbacks.remove(uuid);
+        if (callback == null) {
+            return;
+        }
+        StringBuilder sb = new StringBuilder();
+        for (String page : event.getNewBookMeta().getPages()) {
+            if (page != null) {
+                sb.append(page);
+            }
+        }
+        callback.accept(sb.toString());
+    }
+}

SimpleAPI/src/main/java/com/bencodez/simpleapi/valuerequest/BooleanListener.java

@@ -0,0 +1,17 @@
+package com.bencodez.simpleapi.valuerequest;
+
+import org.bukkit.entity.Player;
+
+/**
+ * Callback interface for when a boolean value has been provided by a player.
+ */
+@FunctionalInterface
+public interface BooleanListener {
+    /**
+     * Invoked when the player submits a boolean value.
+     *
+     * @param player the player who provided the input
+     * @param value  the submitted boolean value
+     */
+    void onInput(Player player, boolean value);
+}

SimpleAPI/src/main/java/com/bencodez/simpleapi/valuerequest/InputMethod.java

@@ -0,0 +1,61 @@
+package com.bencodez.simpleapi.valuerequest;
+
+/**
+ * Represents the different input mechanisms available when requesting a value
+ * from a player. DIALOG is preferred on modern servers with UniDialog
+ * support. CHAT falls back to simple chat prompts when no dialog platform
+ * is available or when running on older versions.
+ */
+public enum InputMethod {
+    /**
+     * Use a UniDialog multi action dialog. This provides a GUI with buttons
+     * and inputs where available.
+     */
+    DIALOG,
+    /**
+     * Use a chat based conversation. Players type their response into chat.
+     */
+    CHAT,
+    /**
+     * Use an in-game inventory interface for selecting options. When using this
+     * method, options are presented as items in a chest-style inventory and a
+     * player may click to select a value. If custom input is allowed a special
+     * item will appear that directs the player to the chat input fallback.
+     */
+    INVENTORY,
+    /**
+     * Use a writable book and quill for input. When this method is selected the
+     * player receives a book in their inventory and must write their response
+     * inside. Once the book is signed the input is captured and processed.
+     */
+    BOOK,
+
+    /**
+     * Use a sign editing interface for input. When selected the player will be
+     * shown a sign where they can type text across multiple lines. Upon
+     * confirmation the text from the sign will be passed to the value request
+     * handler. This method is useful on some server versions that support
+     * {@link org.bukkit.entity.Player#openSign(org.bukkit.block.Sign)}. It
+     * behaves similarly to {@link #BOOK} but uses a sign instead of a
+     * writable book.
+     */
+    SIGN;
+
+    /**
+     * Attempt to parse an input method from a string. If the value is not
+     * recognised this method returns {@link #DIALOG} by default.
+     *
+     * @param method the method name to parse
+     * @return the resolved input method
+     */
+    public static InputMethod getMethod(String method) {
+        if (method != null) {
+            for (InputMethod input : values()) {
+                if (input.toString().equalsIgnoreCase(method)) {
+                    return input;
+                }
+            }
+        }
+        return DIALOG;
+    }
+}